Adding the new rewrite

app/routes/api_ups.py

@@ -0,0 +1,356 @@
+"""Per-UPS data APIs: status, history, metric, events, energy, health, battery health, export, debug, tiles."""
+import json
+import time
+
+import orjson
+from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi.responses import StreamingResponse
+
+from ..apc_cli import APCStatusError, fetch_status
+from ..auth import require_session, require_session_and_csrf
+from ..config import load_config
+from ..exports import export_energy_csv, export_events_csv, export_history_csv
+from ..storage import get_history, get_latest, get_redis
+
+router = APIRouter(prefix="/api/ups")
+
+
+@router.get("")
+async def list_ups(user=Depends(require_session)):
+    cfg = load_config()
+    return [{"name": u.name, "host": u.host, "port": u.port} for u in cfg.ups]
+
+
+@router.get("/fleet/overview")
+async def fleet_overview(user=Depends(require_session)):
+    """Aggregate summary across all UPS."""
+    cfg = load_config()
+    r = get_redis()
+    total = len(cfg.ups)
+    counts = {"online": 0, "on_battery": 0, "warning": 0, "offline": 0, "unknown": 0}
+    total_watts = 0.0
+    min_timeleft = None
+    rows = []
+    for ups in cfg.ups:
+        snap = r.hgetall(f"ups:snap:{ups.name}") or {}
+        is_offline = bool(r.get(f"ups:health:offline:{ups.name}"))
+        status = str(snap.get("STATUS", "")).upper()
+        state = "unknown"
+        if is_offline:
+            state = "offline"
+        elif "ONBATT" in status:
+            state = "on_battery"
+        elif "ONLINE" in status:
+            state = "online"
+        counts[state] = counts.get(state, 0) + 1
+        try:
+            w = float(snap.get("DERIVED_WATTS", 0) or 0)
+            total_watts += w
+        except ValueError:
+            pass
+        try:
+            tl = float(str(snap.get("TIMELEFT", "")).split()[0])
+            if min_timeleft is None or tl < min_timeleft:
+                min_timeleft = tl
+        except Exception:
+            pass
+        rows.append({"name": ups.name, "state": state, "status": status})
+    return {
+        "total": total,
+        "counts": counts,
+        "total_watts": round(total_watts, 1),
+        "min_timeleft_minutes": min_timeleft,
+        "rows": rows,
+    }
+
+
+@router.get("/{ups_name}")
+async def ups_status(ups_name: str, user=Depends(require_session)):
+    snap = await get_latest(ups_name)
+    return snap or {"error": "not found"}
+
+
+@router.get("/{ups_name}/history")
+async def ups_history(ups_name: str, user=Depends(require_session)):
+    return await get_history(ups_name)
+
+
+@router.get("/{ups_name}/metric/{metric}")
+async def metric_history(
+    ups_name: str, metric: str, limit: int = 120, user=Depends(require_session)
+):
+    limit = max(1, min(limit, 500))
+    all_hist = await get_history(ups_name)
+    recent = all_hist[-limit:]
+    out = []
+    for item in recent:
+        data = item.get("data", {})
+        raw_val = data.get(metric)
+        if raw_val is None:
+            continue
+        try:
+            val = float(str(raw_val).split()[0])
+        except Exception:
+            continue
+        out.append({"ts": item.get("ts"), "value": val})
+    return out
+
+
+@router.get("/{ups_name}/events")
+async def ups_events(ups_name: str, user=Depends(require_session)):
+    r = get_redis()
+    raw = r.lrange(f"ups:event:list:{ups_name}", 0, 99)
+    parsed = []
+    for item in raw:
+        if "|" in item:
+            try:
+                ts_s, kind, rest = item.split("|", 2)
+                parsed.append({"ts": int(ts_s), "type": kind, "detail": rest})
+                continue
+            except Exception:
+                pass
+        parsed.append({"raw": item})
+    return parsed
+
+
+@router.get("/{ups_name}/energy")
+async def ups_energy(ups_name: str, user=Depends(require_session)):
+    r = get_redis()
+    day_str = time.strftime("%Y%m%d")
+    key = f"ups:energy:{ups_name}:{day_str}"
+    watt_seconds = r.get(key)
+    cfg = load_config()
+    rate = cfg.ui.energy_cost_per_kwh if hasattr(cfg.ui, "energy_cost_per_kwh") else 0.0
+    if watt_seconds:
+        try:
+            ws = float(watt_seconds)
+            kwh = ws / 3600.0 / 1000.0
+            return {"kwh_today": round(kwh, 4), "cost_today": round(kwh * rate, 4)}
+        except ValueError:
+            pass
+    return {"kwh_today": None, "cost_today": None}
+
+
+@router.get("/{ups_name}/watts_per_minute")
+async def ups_watts_per_minute(ups_name: str, user=Depends(require_session)):
+    r = get_redis()
+    raw = r.lrange(f"ups:watts:permin:{ups_name}", 0, 1440)
+    out = []
+    for item in raw:
+        if "|" in item:
+            minute, avg = item.split("|", 1)
+            try:
+                out.append({"minute": minute, "avg_watts": float(avg)})
+            except ValueError:
+                continue
+    out.reverse()
+    return out
+
+
+@router.get("/{ups_name}/health")
+async def ups_health(ups_name: str, user=Depends(require_session)):
+    r = get_redis()
+    alert_raw = r.lrange(f"ups:alerts:recent:{ups_name}", 0, 19)
+    alerts = []
+    for a in alert_raw:
+        parts = a.split("|", 2)
+        if len(parts) == 3:
+            try:
+                alerts.append({"ts": int(parts[0]), "severity": parts[1], "msg": parts[2]})
+                continue
+            except ValueError:
+                pass
+        if "|" in a:
+            ts_s, msg = a.split("|", 1)
+            try:
+                alerts.append({"ts": int(ts_s), "msg": msg})
+                continue
+            except ValueError:
+                pass
+        alerts.append({"raw": a})
+    dev_samples = r.lrange(f"ups:volt:dev:samples:{ups_name}", 0, 49)
+    dev_vals = []
+    for d in dev_samples:
+        try:
+            dev_vals.append(float(d))
+        except ValueError:
+            continue
+    dev_avg = sum(dev_vals) / len(dev_vals) if dev_vals else None
+    dev_max = max(dev_vals) if dev_vals else None
+    last_ok = r.get(f"ups:health:last_ok:{ups_name}")
+    is_offline = bool(r.get(f"ups:health:offline:{ups_name}"))
+    fail_count = r.get(f"ups:health:fail_count:{ups_name}")
+    events = r.lrange(f"ups:event:list:{ups_name}", 0, 200)
+    now = int(time.time())
+    onbatt_hour = 0
+    for ev in events:
+        parts = ev.split("|")
+        if len(parts) >= 3:
+            try:
+                ts_e = int(parts[0])
+            except ValueError:
+                continue
+            if now - ts_e > 3600:
+                continue
+            if parts[1] == "STATUS" and "ONBATT" in parts[2]:
+                onbatt_hour += 1
+    return {
+        "online": not is_offline,
+        "last_ok_ts": int(last_ok) if last_ok else None,
+        "fail_count": int(fail_count) if fail_count else 0,
+        "alerts": alerts,
+        "voltage_deviation": {
+            "avg_pct": round(dev_avg, 2) if dev_avg is not None else None,
+            "max_pct": round(dev_max, 2) if dev_max is not None else None,
+            "samples": len(dev_vals),
+        },
+        "onbatt_last_hour": onbatt_hour,
+    }
+
+
+@router.get("/{ups_name}/battery_health")
+async def battery_health(ups_name: str, user=Depends(require_session)):
+    """Return battery-health trend from sampled history."""
+    r = get_redis()
+    raw = r.lrange(f"ups:battery:history:{ups_name}", 0, -1)
+    samples = []
+    for item in raw:
+        try:
+            samples.append(json.loads(item))
+        except Exception:
+            continue
+    samples.sort(key=lambda s: s.get("ts", 0))
+    # Estimate runtime-at-full-charge: TIMELEFT * (100 / BCHARGE) when BCHARGE>0
+    normalized = []
+    for s in samples:
+        bc = s.get("bcharge")
+        tl = s.get("timeleft")
+        if bc and tl and bc > 10:
+            normalized.append({"ts": s["ts"], "est_full_runtime_min": tl * 100.0 / bc})
+    slope_per_day = None
+    decline_pct_14d = None
+    if len(normalized) >= 10:
+        first = normalized[0]
+        last = normalized[-1]
+        span_days = max(1e-6, (last["ts"] - first["ts"]) / 86400.0)
+        slope_per_day = (last["est_full_runtime_min"] - first["est_full_runtime_min"]) / span_days
+        # Compute 14d decline as % of initial runtime
+        cutoff_14d = last["ts"] - 14 * 86400
+        older = [n for n in normalized if n["ts"] <= cutoff_14d]
+        if older:
+            baseline = older[0]["est_full_runtime_min"]
+            if baseline > 0:
+                decline_pct_14d = (
+                    (baseline - last["est_full_runtime_min"]) / baseline * 100.0
+                )
+    return {
+        "samples": len(samples),
+        "estimated_full_runtime_samples": normalized[-200:],
+        "slope_per_day": round(slope_per_day, 3) if slope_per_day is not None else None,
+        "decline_pct_14d": round(decline_pct_14d, 2) if decline_pct_14d is not None else None,
+    }
+
+
+@router.get("/{ups_name}/export")
+async def export_ups(
+    ups_name: str,
+    format: str = Query("csv"),
+    since_days: int = Query(7, ge=1, le=30),
+    kind: str = Query("history"),
+    user=Depends(require_session),
+):
+    if format != "csv":
+        raise HTTPException(status_code=400, detail="Only csv format is supported")
+    if kind == "history":
+        gen = export_history_csv(ups_name, since_days)
+        filename = f"{ups_name}_history_{since_days}d.csv"
+    elif kind == "events":
+        gen = export_events_csv(ups_name, since_days)
+        filename = f"{ups_name}_events_{since_days}d.csv"
+    elif kind == "energy":
+        gen = export_energy_csv(ups_name, since_days)
+        filename = f"{ups_name}_energy_{since_days}d.csv"
+    else:
+        raise HTTPException(status_code=400, detail="kind must be history|events|energy")
+    return StreamingResponse(
+        gen,
+        media_type="text/csv",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )
+
+
+@router.get("/{ups_name}/debug")
+async def ups_debug(ups_name: str, user=Depends(require_session)):
+    cfg = load_config()
+    target = next((u for u in cfg.ups if u.name == ups_name), None)
+    if not target:
+        raise HTTPException(status_code=404, detail="UPS not found")
+    try:
+        return await fetch_status(target.host, target.port)
+    except APCStatusError as e:
+        raise HTTPException(status_code=502, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/{ups_name}/ui_tiles")
+async def get_ups_ui_tiles(ups_name: str, user=Depends(require_session)):
+    r = get_redis()
+    raw = r.get(f"ups:ui:tiles:{ups_name}")
+    default = {"types": {}, "order": [], "hidden": [], "custom": [], "positions": {}}
+    if not raw:
+        return default
+    try:
+        data = orjson.loads(raw)
+        return {
+            "types": data.get("types", {}),
+            "order": data.get("order", []),
+            "hidden": data.get("hidden", []),
+            "custom": data.get("custom", []),
+            "positions": data.get("positions", {}),
+        }
+    except Exception:
+        return default
+
+
+@router.post("/{ups_name}/ui_tiles")
+async def save_ups_ui_tiles(
+    ups_name: str, payload: dict, user=Depends(require_session_and_csrf)
+):
+    types = payload.get("types") if isinstance(payload.get("types"), dict) else {}
+    order = payload.get("order") if isinstance(payload.get("order"), list) else []
+    hidden = payload.get("hidden") if isinstance(payload.get("hidden"), list) else []
+    custom = payload.get("custom") if isinstance(payload.get("custom"), list) else []
+    positions = payload.get("positions") if isinstance(payload.get("positions"), dict) else {}
+    norm_custom = []
+    for c in custom or []:
+        if not isinstance(c, dict):
+            continue
+        metric = c.get("metric")
+        chart = c.get("chart")
+        if not metric or not chart:
+            continue
+        norm_custom.append({
+            "id": c.get("id") or "",
+            "metric": metric,
+            "chart": chart,
+            "source": c.get("source", "live"),
+        })
+    doc = {
+        "types": types,
+        "order": order,
+        "hidden": hidden,
+        "custom": norm_custom,
+        "positions": positions,
+        "saved_ts": int(time.time()),
+    }
+    r = get_redis()
+    r.set(f"ups:ui:tiles:{ups_name}", orjson.dumps(doc))
+    return {"message": "saved", "count_custom": len(norm_custom)}
+
+
+@router.delete("/{ups_name}/ui_tiles")
+async def clear_ups_ui_tiles(ups_name: str, user=Depends(require_session_and_csrf)):
+    r = get_redis()
+    r.delete(f"ups:ui:tiles:{ups_name}")
+    return {"message": "cleared"}