479 lines
16 KiB
Python
479 lines
16 KiB
Python
"""GET /sites/{site_id}/status/full – monitoring snapshot + alert pravidla."""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
from datetime import date, datetime, timedelta, timezone
|
||
from typing import Annotated, Any, Literal
|
||
from zoneinfo import ZoneInfo
|
||
|
||
import asyncpg
|
||
from fastapi import APIRouter, Depends, HTTPException
|
||
from pydantic import BaseModel, Field
|
||
|
||
from app.db_json import fetch_json
|
||
from app.deps import get_pg_pool
|
||
from app.notifications_logic import (
|
||
EvSessionRow,
|
||
NegWindowRow,
|
||
PriceSlot,
|
||
build_smart_notifications,
|
||
)
|
||
|
||
router = APIRouter(prefix="/sites/{site_id}", tags=["sites"])
|
||
|
||
|
||
class SiteNotificationItem(BaseModel):
|
||
id: str
|
||
level: Literal["success", "info", "warning", "error"]
|
||
title: str
|
||
body: str
|
||
eta_minutes: int | None = None
|
||
action: Literal["connect_ev", "replan", "import_prices", "switch_auto"] | None = None
|
||
|
||
|
||
class SiteNotificationsResponse(BaseModel):
|
||
notifications: list[SiteNotificationItem] = Field(default_factory=list)
|
||
|
||
INV_STALE_SEC = 300
|
||
HEARTBEAT_STALE_SEC = 300
|
||
EXPECTED_TOMORROW_PRICE_SLOTS = 90
|
||
|
||
|
||
def _iso_utc(dt: datetime | None) -> str | None:
|
||
if dt is None:
|
||
return None
|
||
if dt.tzinfo is None:
|
||
dt = dt.replace(tzinfo=timezone.utc)
|
||
return dt.astimezone(timezone.utc).isoformat()
|
||
|
||
|
||
def _parse_ts(val: Any) -> datetime | None:
|
||
if val is None:
|
||
return None
|
||
if isinstance(val, datetime):
|
||
return val
|
||
if isinstance(val, str):
|
||
return datetime.fromisoformat(val.replace("Z", "+00:00"))
|
||
return None
|
||
|
||
|
||
def _age_seconds(at: datetime | None) -> int | None:
|
||
if at is None:
|
||
return None
|
||
if at.tzinfo is None:
|
||
at = at.replace(tzinfo=timezone.utc)
|
||
return max(0, int((datetime.now(timezone.utc) - at).total_seconds()))
|
||
|
||
|
||
def _next_plan_interval(
|
||
intervals: list[dict[str, Any]], now_utc: datetime
|
||
) -> tuple[str | None, int | None]:
|
||
"""Nejbližší 15min slot od aktuálního času včetně probíhajícího."""
|
||
slot_ms = 15 * 60 * 1000
|
||
boundary_ms = (int(now_utc.timestamp() * 1000) // slot_ms) * slot_ms
|
||
boundary = datetime.fromtimestamp(boundary_ms / 1000, tz=timezone.utc)
|
||
for row in sorted(intervals, key=lambda r: r["interval_start"]):
|
||
istart = row["interval_start"]
|
||
if isinstance(istart, str):
|
||
istart = datetime.fromisoformat(istart.replace("Z", "+00:00"))
|
||
if istart.tzinfo is None:
|
||
istart = istart.replace(tzinfo=timezone.utc)
|
||
if istart >= boundary - timedelta(milliseconds=1):
|
||
bat = row.get("battery_setpoint_w")
|
||
bi = int(bat) if bat is not None else None
|
||
return _iso_utc(istart), bi
|
||
return None, None
|
||
|
||
|
||
@router.get("/status/full")
|
||
async def get_site_status_full(
|
||
site_id: int,
|
||
pool: Annotated[asyncpg.Pool, Depends(get_pg_pool)],
|
||
) -> dict[str, Any]:
|
||
async with pool.acquire() as conn:
|
||
bundle = await fetch_json(
|
||
conn,
|
||
"select ems.fn_site_full_status($1::int)",
|
||
site_id,
|
||
)
|
||
if not isinstance(bundle, dict):
|
||
bundle = json.loads(bundle)
|
||
if bundle.get("error") == "not_found":
|
||
raise HTTPException(status_code=404, detail="Site not found")
|
||
|
||
site = bundle.get("site") or {}
|
||
mode_row = bundle.get("operating_mode") or {}
|
||
hb_row = bundle.get("heartbeat") or {}
|
||
inv_row = bundle.get("inverter_latest")
|
||
if not isinstance(inv_row, dict):
|
||
inv_row = None
|
||
ev_rows = bundle.get("ev_chargers") or []
|
||
if not isinstance(ev_rows, list):
|
||
ev_rows = []
|
||
hp_row = bundle.get("heat_pump_latest")
|
||
if not isinstance(hp_row, dict):
|
||
hp_row = None
|
||
reserve_row = bundle.get("battery_limits") or {}
|
||
run_row = bundle.get("active_plan")
|
||
if not isinstance(run_row, dict):
|
||
run_row = None
|
||
intervals: list[dict[str, Any]] = []
|
||
raw_iv = bundle.get("planning_intervals") or []
|
||
if isinstance(raw_iv, list):
|
||
intervals = [x for x in raw_iv if isinstance(x, dict)]
|
||
|
||
tomorrow_slots = int(bundle.get("tomorrow_price_slot_count") or 0)
|
||
|
||
now_utc = datetime.now(timezone.utc)
|
||
hb_last = hb_row.get("last_seen") if hb_row else None
|
||
hb_age = _age_seconds(hb_last)
|
||
inv_measured = inv_row.get("measured_at") if inv_row else None
|
||
inv_age = _age_seconds(inv_measured)
|
||
|
||
next_start, next_bat = _next_plan_interval(intervals, now_utc)
|
||
|
||
ev_list: list[dict[str, Any]] = []
|
||
for r in ev_rows:
|
||
if not isinstance(r, dict):
|
||
continue
|
||
ev_list.append(
|
||
{
|
||
"code": r.get("code"),
|
||
"status": r.get("status"),
|
||
"power_w": int(r["power_w"]) if r.get("power_w") is not None else None,
|
||
}
|
||
)
|
||
|
||
telemetry: dict[str, Any] = {
|
||
"inverter": {
|
||
"pv_power_w": int(inv_row["pv_power_w"])
|
||
if inv_row and inv_row.get("pv_power_w") is not None
|
||
else None,
|
||
"battery_soc_pct": float(inv_row["battery_soc_percent"])
|
||
if inv_row and inv_row.get("battery_soc_percent") is not None
|
||
else None,
|
||
"grid_power_w": int(inv_row["grid_power_w"])
|
||
if inv_row and inv_row.get("grid_power_w") is not None
|
||
else None,
|
||
"measured_at": _iso_utc(inv_measured),
|
||
"age_seconds": inv_age,
|
||
},
|
||
"ev_chargers": ev_list,
|
||
"heat_pump": {
|
||
"power_w": int(hp_row["power_w"]) if hp_row and hp_row.get("power_w") is not None else None,
|
||
"tank_temp_c": float(hp_row["tuv_tank_temp_c"])
|
||
if hp_row and hp_row.get("tuv_tank_temp_c") is not None
|
||
else None,
|
||
"measured_at": _iso_utc(hp_row.get("measured_at")) if hp_row else None,
|
||
},
|
||
}
|
||
|
||
has_plan = run_row is not None
|
||
planning = {
|
||
"has_active_plan": has_plan,
|
||
"plan_created_at": _iso_utc(run_row.get("created_at")) if run_row else None,
|
||
"next_interval_start": next_start,
|
||
"next_battery_setpoint_w": next_bat,
|
||
}
|
||
|
||
mode_code = (mode_row.get("mode_code") if mode_row else None) or ""
|
||
reserve_soc = (
|
||
float(reserve_row["reserve_soc"])
|
||
if reserve_row and reserve_row.get("reserve_soc") is not None
|
||
else None
|
||
)
|
||
min_soc = (
|
||
float(reserve_row["min_soc"]) if reserve_row and reserve_row.get("min_soc") is not None else None
|
||
)
|
||
soc = (
|
||
float(inv_row["battery_soc_percent"])
|
||
if inv_row and inv_row.get("battery_soc_percent") is not None
|
||
else None
|
||
)
|
||
|
||
alerts: list[dict[str, str]] = []
|
||
|
||
def add_alert(level: Literal["warn", "error"], message: str) -> None:
|
||
alerts.append({"level": level, "message": message})
|
||
|
||
if inv_age is None or inv_age > INV_STALE_SEC:
|
||
add_alert("error", "Telemetrie střídače nedostupná")
|
||
|
||
if not has_plan:
|
||
add_alert("warn", "Není aktivní plán – EMS neoptimalizuje")
|
||
|
||
# OTE D+1 typicky až po ~14:30 Europe/Prague – před tím nevarovat
|
||
now_prague = datetime.now(ZoneInfo("Europe/Prague"))
|
||
prices_expected = (now_prague.hour, now_prague.minute) >= (14, 30)
|
||
if tomorrow_slots < EXPECTED_TOMORROW_PRICE_SLOTS and prices_expected:
|
||
add_alert("warn", "Chybí spotové ceny pro zítřek")
|
||
|
||
if mode_code.upper() == "MANUAL":
|
||
add_alert("warn", "Systém v manuálním režimu")
|
||
|
||
if min_soc is not None and soc is not None and soc < min_soc:
|
||
add_alert("error", "SoC baterie pod minimálním limitem")
|
||
elif reserve_soc is not None and soc is not None and soc < reserve_soc:
|
||
add_alert("warn", "SoC pod ekonomickou rezervou (arbitrážní podlaha)")
|
||
|
||
if hb_age is None or hb_age > HEARTBEAT_STALE_SEC:
|
||
add_alert("error", "EMS heartbeat výpadek")
|
||
|
||
alerts.sort(key=lambda a: (0 if a["level"] == "error" else 1, a["message"]))
|
||
|
||
return {
|
||
"site": {"id": site.get("id"), "code": site.get("code"), "name": site.get("name")},
|
||
"operating_mode": {
|
||
"mode_code": mode_row.get("mode_code") if mode_row else None,
|
||
"mode_name": mode_row.get("mode_name") if mode_row else None,
|
||
"activated_at": _iso_utc(mode_row.get("activated_at")) if mode_row else None,
|
||
"activated_by": mode_row.get("activated_by") if mode_row else None,
|
||
},
|
||
"heartbeat": {
|
||
"last_seen": _iso_utc(hb_last),
|
||
"age_seconds": hb_age,
|
||
"status": hb_row.get("status") if hb_row else None,
|
||
},
|
||
"telemetry": telemetry,
|
||
"planning": planning,
|
||
"alerts": alerts,
|
||
}
|
||
|
||
|
||
_NOTIF_LEVEL_PRIORITY = {"error": 0, "success": 1, "warning": 2, "info": 3}
|
||
|
||
|
||
def _infrastructure_notification_items(
|
||
*,
|
||
has_plan: bool,
|
||
tomorrow_slots: int,
|
||
mode_code: str,
|
||
min_soc: float | None,
|
||
reserve_soc: float | None,
|
||
soc: float | None,
|
||
inv_age: int | None,
|
||
hb_age: int | None,
|
||
) -> list[SiteNotificationItem]:
|
||
"""Kritické / provozní notifikace (telemetrie, plán, ceny, režim, heartbeat)."""
|
||
items: list[SiteNotificationItem] = []
|
||
|
||
def push(
|
||
nid: str,
|
||
level: Literal["success", "info", "warning", "error"],
|
||
title: str,
|
||
body: str,
|
||
*,
|
||
eta_minutes: int | None = None,
|
||
action: Literal["connect_ev", "replan", "import_prices", "switch_auto"] | None = None,
|
||
) -> None:
|
||
items.append(
|
||
SiteNotificationItem(
|
||
id=nid,
|
||
level=level,
|
||
title=title,
|
||
body=body,
|
||
eta_minutes=eta_minutes,
|
||
action=action,
|
||
)
|
||
)
|
||
|
||
if inv_age is None or inv_age > INV_STALE_SEC:
|
||
push("telemetry_inverter", "error", "Telemetrie střídače", "Data ze střídače nejsou aktuální.")
|
||
|
||
if not has_plan:
|
||
push(
|
||
"no_active_plan",
|
||
"warning",
|
||
"Chybí aktivní plán",
|
||
"EMS zatím neoptimalizuje provoz – spusťte plánování.",
|
||
action="replan",
|
||
)
|
||
|
||
now_prague = datetime.now(ZoneInfo("Europe/Prague"))
|
||
prices_expected = (now_prague.hour, now_prague.minute) >= (14, 30)
|
||
if tomorrow_slots < EXPECTED_TOMORROW_PRICE_SLOTS and prices_expected:
|
||
push(
|
||
"prices_tomorrow",
|
||
"warning",
|
||
"Ceny na zítřek",
|
||
"Nejsou kompletní spotové ceny OTE pro následující den.",
|
||
action="import_prices",
|
||
)
|
||
|
||
if mode_code.upper() == "MANUAL":
|
||
push("mode_manual", "info", "Manuální režim", "Automatická optimalizace je vypnutá.")
|
||
|
||
if min_soc is not None and soc is not None and soc < min_soc:
|
||
push(
|
||
"soc_min",
|
||
"error",
|
||
"SoC pod minimem",
|
||
"SoC je pod absolutním minimem z konfigurace baterie.",
|
||
)
|
||
elif reserve_soc is not None and soc is not None and soc < reserve_soc:
|
||
push(
|
||
"soc_reserve",
|
||
"warning",
|
||
"SoC pod ekonomickou rezervou",
|
||
"SoC je pod arbitrážní podlahou – plánovač může v tomto pásmu omezovat export.",
|
||
)
|
||
|
||
if hb_age is None or hb_age > HEARTBEAT_STALE_SEC:
|
||
push("heartbeat", "error", "EMS heartbeat", "Služba EMS nehlásí pravidelný heartbeat.")
|
||
|
||
return items
|
||
|
||
|
||
def _float_or_none(v: Any) -> float | None:
|
||
if v is None:
|
||
return None
|
||
return float(v)
|
||
|
||
|
||
@router.get("/notifications", response_model=SiteNotificationsResponse)
|
||
async def get_site_notifications(
|
||
site_id: int,
|
||
pool: Annotated[asyncpg.Pool, Depends(get_pg_pool)],
|
||
) -> SiteNotificationsResponse:
|
||
async with pool.acquire() as conn:
|
||
ctx = await fetch_json(
|
||
conn,
|
||
"select ems.fn_site_notifications_context($1::int)",
|
||
site_id,
|
||
)
|
||
if not isinstance(ctx, dict):
|
||
ctx = json.loads(ctx)
|
||
if ctx.get("error") == "not_found":
|
||
raise HTTPException(status_code=404, detail="Site not found")
|
||
|
||
has_plan = bool(ctx.get("has_plan"))
|
||
mode_code = (ctx.get("mode_code") or "") or ""
|
||
reserve_soc = _float_or_none(ctx.get("reserve_soc"))
|
||
min_soc = _float_or_none(ctx.get("min_soc"))
|
||
soc = _float_or_none(ctx.get("soc_pct"))
|
||
inv_age = _age_seconds(_parse_ts(ctx.get("inv_measured_at")))
|
||
hb_age = _age_seconds(_parse_ts(ctx.get("hb_last_seen")))
|
||
tomorrow_slots = int(ctx.get("tomorrow_slots") or 0)
|
||
|
||
price_rows = ctx.get("price_slots") or []
|
||
if not isinstance(price_rows, list):
|
||
price_rows = []
|
||
|
||
avg_buy = _float_or_none(ctx.get("avg_buy"))
|
||
usable_wh = _float_or_none(ctx.get("usable_wh"))
|
||
|
||
ev_rows = ctx.get("ev_sessions") or []
|
||
if not isinstance(ev_rows, list):
|
||
ev_rows = []
|
||
|
||
neg_rows = ctx.get("neg_windows") or []
|
||
if not isinstance(neg_rows, list):
|
||
neg_rows = []
|
||
|
||
infra = _infrastructure_notification_items(
|
||
has_plan=has_plan,
|
||
tomorrow_slots=int(tomorrow_slots or 0),
|
||
mode_code=mode_code,
|
||
min_soc=min_soc,
|
||
reserve_soc=reserve_soc,
|
||
soc=soc,
|
||
inv_age=inv_age,
|
||
hb_age=hb_age,
|
||
)
|
||
|
||
prices: list[PriceSlot] = []
|
||
for r in price_rows:
|
||
if not isinstance(r, dict):
|
||
continue
|
||
buy = _float_or_none(r.get("effective_buy_price_czk_kwh"))
|
||
if buy is None:
|
||
continue
|
||
sell_v = _float_or_none(r.get("effective_sell_price_czk_kwh"))
|
||
istart = r.get("interval_start")
|
||
if isinstance(istart, str):
|
||
istart = datetime.fromisoformat(istart.replace("Z", "+00:00"))
|
||
prices.append(
|
||
PriceSlot(
|
||
interval_start=istart,
|
||
buy=buy,
|
||
sell=sell_v if sell_v is not None else buy,
|
||
)
|
||
)
|
||
|
||
battery_kwh = (usable_wh / 1000.0) if usable_wh is not None else None
|
||
|
||
ev_sessions: list[EvSessionRow] = []
|
||
for er in ev_rows:
|
||
if not isinstance(er, dict):
|
||
continue
|
||
ss = er.get("session_start")
|
||
if isinstance(ss, str):
|
||
ss = datetime.fromisoformat(ss.replace("Z", "+00:00"))
|
||
ev_sessions.append(
|
||
EvSessionRow(
|
||
id=int(er["id"]),
|
||
charger_id=int(er["charger_id"]),
|
||
energy_delivered_wh=float(er.get("energy_delivered_wh") or 0),
|
||
target_soc_pct=_float_or_none(er.get("target_soc_pct")),
|
||
session_start=ss,
|
||
battery_capacity_kwh=_float_or_none(er.get("battery_capacity_kwh")),
|
||
make=er.get("make"),
|
||
model=er.get("model"),
|
||
default_target_soc_pct=_float_or_none(er.get("default_target_soc_pct")),
|
||
charger_code=str(er.get("charger_code") or ""),
|
||
soc_at_connect_pct=_float_or_none(er.get("soc_at_connect_pct")),
|
||
)
|
||
)
|
||
|
||
neg_windows: list[NegWindowRow] = []
|
||
for nr in neg_rows:
|
||
if not isinstance(nr, dict):
|
||
continue
|
||
dr = nr.get("predicted_date")
|
||
if isinstance(dr, datetime):
|
||
d_conv = dr.date()
|
||
elif isinstance(dr, date):
|
||
d_conv = dr
|
||
elif isinstance(dr, str):
|
||
d_conv = date.fromisoformat(dr[:10])
|
||
else:
|
||
d_conv = date.today()
|
||
neg_windows.append(
|
||
NegWindowRow(
|
||
predicted_date=d_conv,
|
||
window_start_hour=int(nr.get("window_start_hour") or 0),
|
||
window_end_hour=int(nr.get("window_end_hour") or 0),
|
||
probability_pct=int(nr.get("probability_pct") or 0),
|
||
)
|
||
)
|
||
|
||
sell_now = prices[0].sell if prices else None
|
||
|
||
smart_raw = build_smart_notifications(
|
||
prices=prices,
|
||
avg_buy=avg_buy,
|
||
soc_pct=soc,
|
||
battery_kwh=battery_kwh,
|
||
ev_sessions=ev_sessions,
|
||
neg_windows=neg_windows,
|
||
mode=mode_code,
|
||
sell_price_now=sell_now,
|
||
)
|
||
|
||
smart_items = [
|
||
SiteNotificationItem(
|
||
id=d["id"],
|
||
level=d["level"],
|
||
title=d["title"],
|
||
body=d["body"],
|
||
eta_minutes=d.get("eta_minutes"),
|
||
action=d.get("action"),
|
||
)
|
||
for d in smart_raw
|
||
]
|
||
|
||
merged = infra + smart_items
|
||
merged.sort(key=lambda x: _NOTIF_LEVEL_PRIORITY.get(x.level, 9))
|
||
return SiteNotificationsResponse(notifications=merged[:5])
|