Initial commit

Made-with: Cursor

backend/app/main.py

@@ -0,0 +1,157 @@
+"""EMS FastAPI – health, provozní režimy, PostgREST doplňky."""
+
+from __future__ import annotations
+
+import logging
+import os
+from contextlib import asynccontextmanager
+from datetime import datetime, timezone
+from typing import Annotated
+
+import asyncpg
+import httpx
+from app.deps import set_pg_pool
+from app.routers.plan import router as plan_router
+from fastapi import Depends, FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+
+def _dsn() -> str:
+    host = os.getenv("DB_HOST", "localhost")
+    port = os.getenv("DB_PORT", "5432")
+    name = os.getenv("DB_NAME", "ems")
+    user = os.getenv("DB_USER", "ems_user")
+    password = os.getenv("DB_PASSWORD", "")
+    return f"postgresql://{user}:{password}@{host}:{port}/{name}"
+
+
+pool: asyncpg.Pool | None = None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global pool
+    pool = await asyncpg.create_pool(_dsn(), min_size=1, max_size=5)
+    set_pg_pool(pool)
+    yield
+    set_pg_pool(None)
+    if pool:
+        await pool.close()
+        pool = None
+
+
+app = FastAPI(title="EMS Platform", lifespan=lifespan)
+
+app.include_router(plan_router, prefix="/api/v1")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=os.getenv("CORS_ORIGINS", "http://localhost:5173,http://127.0.0.1:5173").split(","),
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+async def get_pool() -> asyncpg.Pool:
+    if pool is None:
+        raise HTTPException(status_code=503, detail="Database pool not ready")
+    return pool
+
+
+@app.get("/health")
+async def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+class SetSiteModeBody(BaseModel):
+    mode: str = Field(..., min_length=1)
+    notes: str | None = None
+    valid_until: datetime | None = None
+
+
+class SetSiteModeResponse(BaseModel):
+    success: bool
+    mode: str
+    activated_at: datetime
+
+
+@app.post("/api/v1/sites/{site_id}/mode", response_model=SetSiteModeResponse)
+async def set_site_mode(
+    site_id: int,
+    body: SetSiteModeBody,
+    db: Annotated[asyncpg.Pool, Depends(get_pool)],
+) -> SetSiteModeResponse:
+    mode = body.mode.strip().upper()
+    allowed = {"AUTO", "SELF_SUSTAIN", "CHARGE_CHEAP", "PRESERVE", "MANUAL"}
+    if mode not in allowed:
+        raise HTTPException(status_code=400, detail=f"Unsupported mode: {body.mode}")
+
+    async with db.acquire() as conn:
+        site_ok = await conn.fetchval("SELECT EXISTS(SELECT 1 FROM ems.site WHERE id = $1)", site_id)
+        if not site_ok:
+            raise HTTPException(status_code=404, detail="Site not found")
+
+        try:
+            await conn.execute(
+                "SELECT ems.fn_set_mode($1, $2, $3, $4, $5)",
+                site_id,
+                mode,
+                "user:api",
+                body.valid_until,
+                body.notes,
+            )
+        except asyncpg.PostgresError as e:
+            logger.warning("fn_set_mode failed: %s", e)
+            raise HTTPException(status_code=400, detail=str(e)) from e
+
+        row = await conn.fetchrow(
+            """
+            SELECT m.mode_code, m.activated_at, d.loxone_mode_value
+            FROM ems.site_operating_mode m
+            JOIN ems.operating_mode_def d ON d.code = m.mode_code
+            WHERE m.site_id = $1
+            """,
+            site_id,
+        )
+        if row is None:
+            raise HTTPException(status_code=500, detail="Mode row missing after set")
+
+        ep = await conn.fetchrow(
+            """
+            SELECT host, port, protocol
+            FROM ems.site_endpoint
+            WHERE site_id = $1 AND endpoint_type = 'loxone_http' AND enabled = true
+            ORDER BY id
+            LIMIT 1
+            """,
+            site_id,
+        )
+
+    activated_at: datetime = row["activated_at"]
+    if activated_at.tzinfo is None:
+        activated_at = activated_at.replace(tzinfo=timezone.utc)
+
+    loxone_val: int | None = row["loxone_mode_value"]
+    if ep and loxone_val is not None:
+        proto = (ep["protocol"] or "http").lower()
+        if proto not in ("http", "https"):
+            proto = "http"
+        host = ep["host"]
+        port = int(ep["port"] or (443 if proto == "https" else 80))
+        base = f"{proto}://{host}:{port}"
+        url = f"{base}/dev/sps/io/EMS_Mode/{loxone_val}"
+        user = os.getenv("LOXONE_USER") or ""
+        password = os.getenv("LOXONE_PASSWORD") or ""
+        auth = (user, password) if user else None
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                r = await client.get(url, auth=auth)
+                r.raise_for_status()
+        except Exception as e:
+            logger.warning("Loxone EMS_Mode notify failed for site %s: %s", site_id, e)
+
+    return SetSiteModeResponse(success=True, mode=row["mode_code"], activated_at=activated_at)