Added Multiple Rooms

Author: python2121

app/main.py

@@ -8,7 +8,7 @@
 from fastapi.templating import Jinja2Templates
 
 from app.config import PROJECT_ROOT, settings
-from app.routers import ha_proxy, layout, moon, weather
+from app.routers import ha_proxy, layout, moon, rooms, weather
 
 logging.basicConfig(
     level=logging.DEBUG if settings.debug else logging.INFO,
@@ -29,6 +29,7 @@
 # ---------- Routers ----------
 app.include_router(ha_proxy.router)
 app.include_router(layout.router)
+app.include_router(rooms.router)
 app.include_router(weather.router)
 app.include_router(moon.router)
 

app/models.py

@@ -145,6 +145,13 @@ def _inject_tile_type(cls, data):
         return data
 
 
+class Room(BaseModel):
+    """A named layout context (room)."""
+
+    id: str = Field(description="Unique room identifier (URL-safe slug)")
+    name: str = Field(description="Display name for the room")
+
+
 class ServiceCall(BaseModel):
     """Payload for calling a Home Assistant service."""
 

app/routers/layout.py

@@ -1,32 +1,40 @@
 """Layout persistence routes.
 
-Tile layout is stored as a JSON file on disk (no database needed).
-The file path is configured via settings.layout_file.
+Each room has its own layout file:
+  - "default" room  → settings.layout_file  (e.g. data/layout.json)
+  - other rooms     → data/layout_{room_id}.json
 """
 
 import contextlib
 import json
 import logging
 import os
+import re
 import tempfile
+from pathlib import Path
 
-from fastapi import APIRouter, HTTPException, status
+from fastapi import APIRouter, HTTPException, Query, status
 
 from app.config import settings
 from app.models import Layout
 
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/layout", tags=["layout"])
 
-DEFAULT_LAYOUT = Layout(
-    columns=12,
-    tiles=[],
-)
+ROOM_ID_RE = re.compile(r"^[a-z0-9_]{1,40}$")
 
+DEFAULT_LAYOUT = Layout(columns=12, tiles=[])
 
-def _read_layout() -> Layout:
-    """Read the layout from disk, returning the default if the file doesn't exist."""
-    path = settings.layout_file
+
+def _layout_path(room_id: str) -> Path:
+    base = settings.layout_file
+    if room_id == "default":
+        return base
+    return base.parent / f"layout_{room_id}.json"
+
+
+def _read_layout(room_id: str) -> Layout:
+    path = _layout_path(room_id)
     if not path.exists():
         return DEFAULT_LAYOUT
     try:
@@ -37,9 +45,8 @@ def _read_layout() -> Layout:
         return DEFAULT_LAYOUT
 
 
-def _write_layout(layout: Layout) -> None:
-    """Persist the layout to disk atomically via write-to-temp + rename."""
-    path = settings.layout_file
+def _write_layout(layout: Layout, room_id: str) -> None:
+    path = _layout_path(room_id)
     path.parent.mkdir(parents=True, exist_ok=True)
     fd, tmp_path = tempfile.mkstemp(dir=str(path.parent), suffix=".tmp")
     try:
@@ -53,20 +60,32 @@ def _write_layout(layout: Layout) -> None:
 
 
 @router.get("")
-async def get_layout() -> Layout:
-    """Return the current dashboard layout."""
-    return _read_layout()
+async def get_layout(room_id: str = Query(default="default")) -> Layout:
+    """Return the layout for the given room."""
+    if not ROOM_ID_RE.match(room_id):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid room_id",
+        )
+    return _read_layout(room_id)
 
 
 @router.put("")
-async def save_layout(layout: Layout) -> Layout:
-    """Replace the entire dashboard layout."""
-    # Validate tile IDs are unique
+async def save_layout(
+    layout: Layout,
+    room_id: str = Query(default="default"),
+) -> Layout:
+    """Replace the layout for the given room."""
+    if not ROOM_ID_RE.match(room_id):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid room_id",
+        )
     ids = [t.id for t in layout.tiles]
     if len(ids) != len(set(ids)):
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST,
             detail="Duplicate tile IDs in layout",
         )
-    _write_layout(layout)
+    _write_layout(layout, room_id)
     return layout

app/routers/rooms.py

@@ -0,0 +1,110 @@
+"""Rooms routes — named layout contexts.
+
+Each room has its own saved layout file.  Rooms are stored as a JSON
+list at ``data/rooms.json`` (same directory as the layout file).
+"""
+
+import contextlib
+import json
+import logging
+import os
+import re
+import secrets
+import tempfile
+from typing import List
+
+from fastapi import APIRouter, HTTPException, status
+from pydantic import BaseModel
+
+from app.config import settings
+from app.models import Room
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/api/rooms", tags=["rooms"])
+
+ROOM_ID_RE = re.compile(r"^[a-z0-9_]{1,40}$")
+
+
+class RoomCreate(BaseModel):
+    name: str
+
+
+def _rooms_path():
+    return settings.layout_file.parent / "rooms.json"
+
+
+def _read_rooms() -> List[Room]:
+    path = _rooms_path()
+    if not path.exists():
+        return [Room(id="default", name="Default")]
+    try:
+        raw = path.read_text(encoding="utf-8")
+        data = json.loads(raw)
+        return [Room(**r) for r in data]
+    except (json.JSONDecodeError, ValueError, TypeError):
+        logger.warning("Corrupt rooms file at %s — returning default", path)
+        return [Room(id="default", name="Default")]
+
+
+def _write_rooms(rooms: List[Room]) -> None:
+    path = _rooms_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = [r.model_dump() for r in rooms]
+    fd, tmp = tempfile.mkstemp(dir=str(path.parent), suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+        os.replace(tmp, str(path))
+    except BaseException:
+        with contextlib.suppress(OSError):
+            os.unlink(tmp)
+        raise
+
+
+@router.get("", response_model=List[Room])
+async def list_rooms() -> List[Room]:
+    """Return all rooms."""
+    return _read_rooms()
+
+
+@router.post("", response_model=Room, status_code=status.HTTP_201_CREATED)
+async def create_room(body: RoomCreate) -> Room:
+    """Create a new room."""
+    name = body.name.strip()
+    if not name:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Room name cannot be empty",
+        )
+    slug = re.sub(r"[^a-z0-9]+", "_", name.lower()).strip("_") or "room"
+    slug = slug[:20]
+    room_id = f"{slug}_{secrets.token_hex(3)}"
+    rooms = _read_rooms()
+    new_room = Room(id=room_id, name=name)
+    rooms.append(new_room)
+    _write_rooms(rooms)
+    return new_room
+
+
+@router.delete("/{room_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_room(room_id: str) -> None:
+    """Delete a room and its layout file. Cannot delete the last room."""
+    if not ROOM_ID_RE.match(room_id):
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid room ID",
+        )
+    rooms = _read_rooms()
+    if len(rooms) <= 1:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Cannot delete the last room",
+        )
+    new_rooms = [r for r in rooms if r.id != room_id]
+    if len(new_rooms) == len(rooms):
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Room not found")
+    _write_rooms(new_rooms)
+    # Delete the layout file for this room (ignore if absent)
+    layout_file = settings.layout_file.parent / f"layout_{room_id}.json"
+    with contextlib.suppress(OSError):
+        layout_file.unlink()