BBFbyOpus

app/api/routes/api_keys.py

@@ -1,4 +1,5 @@
 from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
 from sqlalchemy import select
 
 from app.core.database import async_session
@@ -9,6 +10,12 @@ from app.api.deps import require_admin, AuthContext
 router = APIRouter(dependencies=[Depends(require_admin)])
 
 
+class KeyActionRequest(BaseModel):
+    """Тело запроса для операций с ключом (чтобы токен не летел в URL)."""
+
+    key: str
+
+
 @router.get("")
 async def list_keys():
     """Список всех гостевых ключей."""
@@ -49,12 +56,12 @@ async def create_key(name: str, is_admin: bool = False):
     }
 
 
-@router.delete("/{key}")
-async def revoke_key(key: str):
-    """Деактивировать (отозвать) гостевой ключ."""
+@router.post("/revoke")
+async def revoke_key(body: KeyActionRequest):
+    """Деактивировать (отозвать) гостевой ключ. Ключ передаётся в body, не в URL."""
     async with async_session() as session:
         result = await session.execute(
-            select(ApiKeyModel).where(ApiKeyModel.key == key)
+            select(ApiKeyModel).where(ApiKeyModel.key == body.key)
         )
         api_key = result.scalar_one_or_none()
         if not api_key:
@@ -67,12 +74,12 @@ async def revoke_key(key: str):
     return {"status": "revoked", "name": api_key.name}
 
 
-@router.post("/{key}/activate")
-async def activate_key(key: str):
-    """Повторно активировать ключ."""
+@router.post("/activate")
+async def activate_key(body: KeyActionRequest):
+    """Повторно активировать ключ. Ключ передаётся в body, не в URL."""
     async with async_session() as session:
         result = await session.execute(
-            select(ApiKeyModel).where(ApiKeyModel.key == key)
+            select(ApiKeyModel).where(ApiKeyModel.key == body.key)
         )
         api_key = result.scalar_one_or_none()
         if not api_key:

app/api/routes/control.py

@@ -11,7 +11,7 @@ from app.models.event_log import EventLog
 
 logger = logging.getLogger(__name__)
 
-router = APIRouter(dependencies=[Depends(verify_token)])
+router = APIRouter()
 wiz = WizDriver()
 
 
@@ -34,19 +34,21 @@ async def _log_event(
         logger.error(f"Ошибка записи в лог: {e}")
 
 
-def _classify_action(params: dict) -> str:
-    """Определить тип действия по параметрам."""
-    if "state" in params and len(params) == 1:
-        return "toggle_on" if params["state"] else "toggle_off"
-    if "sceneId" in params or "scene" in params:
-        return "scene"
-    if "r" in params or "g" in params or "b" in params:
-        return "color"
-    if "temp" in params:
-        return "temperature"
-    if "dimming" in params:
-        return "brightness"
-    return "control"
+async def log_toggle(auth: AuthContext, target_type: str, target_id: str, params: dict):
+    """Логирует toggle_on/toggle_off если в params есть state."""
+    if "state" in params:
+        action = "toggle_on" if params["state"] else "toggle_off"
+        await _log_event(auth, action, target_type, target_id, params)
+
+
+async def log_toggle_by_name(
+    key_name: str, target_type: str, target_id: str, params: dict
+):
+    """Логирует toggle из контекста без AuthContext (для планировщика)."""
+    if "state" in params:
+        auth = AuthContext(is_master=False, is_admin=False, key_name=key_name)
+        action = "toggle_on" if params["state"] else "toggle_off"
+        await _log_event(auth, action, target_type, target_id, params)
 
 
 @router.post("/device/{device_id}")
@@ -83,8 +85,7 @@ async def control_device(
 
     result = await wiz.set_pilot(device.ip, params)
 
-    # Логируем
-    await _log_event(auth, _classify_action(params), "device", device_id, params)
+    await log_toggle(auth, "device", device_id, params)
 
     return {"device_id": device_id, "applied": params, "result": result}
 
@@ -121,14 +122,13 @@ async def control_group(
     tasks = [wiz.set_pilot(ip, params) for ip in ips]
     await asyncio.gather(*tasks, return_exceptions=True)
 
-    # Логируем
-    await _log_event(auth, _classify_action(params), "group", group_id, params)
+    await log_toggle(auth, "group", group_id, params)
 
     return {"status": "ok", "applied": params, "sent_to": ips}
 
 
 @router.post("/device/{device_id}/blink")
-async def blink_device(device_id: str):
+async def blink_device(device_id: str, _auth: AuthContext = Depends(verify_token)):
     device = state_manager.devices.get(device_id)
     if not device:
         raise HTTPException(status_code=404, detail="Лампа оффлайн")
@@ -146,7 +146,7 @@ async def blink_device(device_id: str):
 
 
 @router.get("/device/{device_id}/status")
-async def get_device_status(device_id: str):
+async def get_device_status(device_id: str, _auth: AuthContext = Depends(verify_token)):
     """Опрос реального состояния конкретной лампы."""
     device = state_manager.devices.get(device_id)
     if not device:
@@ -160,7 +160,7 @@ async def get_device_status(device_id: str):
 
 
 @router.get("/group/{group_id}/status")
-async def get_group_status(group_id: str):
+async def get_group_status(group_id: str, _auth: AuthContext = Depends(verify_token)):
     """Опрос состояния всей группы (возвращает список статусов)."""
     ips = state_manager.get_group_ips(group_id)
     if not ips:

app/api/routes/devices.py

@@ -1,3 +1,4 @@
+import logging
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy import select
 from app.core.state import state_manager, discovery_service
@@ -6,6 +7,8 @@ from app.models.device import GroupModel, GroupCreateSchema
 from app.api.deps import verify_token, require_admin
 from app.drivers.wiz import WizDriver
 
+logger = logging.getLogger(__name__)
+
 # Создаем роутер с защитой
 router = APIRouter(dependencies=[Depends(verify_token)])
 wiz = WizDriver()
@@ -36,6 +39,8 @@ async def create_group(data: GroupCreateSchema):
         new_group = GroupModel(id=data.id, name=data.name, device_ids=data.macs)
         session.add(new_group)
         await session.commit()
+        # Обновляем атрибуты из БД, чтобы избежать DetachedInstanceError
+        await session.refresh(new_group)
         state_manager.groups[data.id] = new_group
     return {"status": "created", "group": data.name}
 
@@ -59,6 +64,22 @@ async def delete_group(group_id: str):
 @router.post("/rescan", dependencies=[Depends(require_admin)])
 async def rescan_network():
     found_devices = await discovery_service.scan_network()
+
+    # MAC-адреса найденных ламп
+    found_macs = {dev["mac"] for dev in found_devices}
+
+    # Удаляем устройства, которые не ответили (оффлайн)
+    offline_macs = [mac for mac in state_manager.devices if mac not in found_macs]
+    for mac in offline_macs:
+        del state_manager.devices[mac]
+        logger.info(f"Устройство {mac} не ответило -- убрано из списка")
+
+    # Обновляем/добавляем найденные
     for dev_data in found_devices:
         state_manager.update_device(dev_data)
-    return {"status": "ok", "found": len(state_manager.devices)}
+
+    return {
+        "status": "ok",
+        "found": len(found_macs),
+        "removed_offline": len(offline_macs),
+    }

app/api/routes/schedules.py

@@ -14,6 +14,9 @@ logger = logging.getLogger(__name__)
 
 router = APIRouter(dependencies=[Depends(require_admin)])
 
+# Префиксы служебных задач -- не показываем на фронте
+_INTERNAL_JOB_PREFIXES = ("cleanup_",)
+
 
 async def run_group_command(target_id: str, is_group: bool, params: dict):
     """
@@ -35,9 +38,16 @@ async def run_group_command(target_id: str, is_group: bool, params: dict):
     for ip in ips:
         try:
             await local_wiz.set_pilot(ip, params)
-            logger.info(f"⏰ Расписание: {target_id} -> {ip}: {params}")
+            logger.info(f"Расписание: {target_id} -> {ip}: {params}")
         except Exception as e:
-            logger.error(f"⏰ Расписание: ошибка {ip}: {e}")
+            logger.error(f"Расписание: ошибка {ip}: {e}")
+
+    # Логируем toggle в event_log
+    # Импорт здесь, чтобы избежать циклической зависимости
+    from app.api.routes.control import log_toggle_by_name
+
+    target_type = "group" if is_group else "device"
+    await log_toggle_by_name("scheduler", target_type, target_id, params)
 
 
 @router.post("/once")
@@ -122,6 +132,10 @@ async def add_cron_task(
 async def get_all_tasks():
     jobs = []
     for job in scheduler.get_jobs():
+        # Пропускаем служебные задачи
+        if any(job.id.startswith(prefix) for prefix in _INTERNAL_JOB_PREFIXES):
+            continue
+
         # Парсим имя
         name_parts = job.name.split("|")
         target = name_parts[0].replace("CRON:", "").replace("Once:", "").strip()
@@ -157,6 +171,10 @@ async def get_all_tasks():
 
 @router.delete("/{job_id}")
 async def cancel_task(job_id: str):
+    # Запрещаем удалять служебные задачи через API
+    if any(job_id.startswith(prefix) for prefix in _INTERNAL_JOB_PREFIXES):
+        raise HTTPException(status_code=403, detail="Нельзя удалить служебную задачу")
+
     try:
         scheduler.remove_job(job_id)
         return {"status": "deleted"}

app/api/routes/stats.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timedelta
 from fastapi import APIRouter, Depends, Query
-from sqlalchemy import select, func, and_, case
+from sqlalchemy import select
 from app.core.database import async_session
 from app.models.event_log import EventLog
 from app.api.deps import require_admin
@@ -12,16 +12,14 @@ router = APIRouter(dependencies=[Depends(require_admin)])
 async def get_summary(days: int = Query(default=7, ge=1, le=365)):
     """
     Сводная статистика за последние N дней.
-    Возвращает по каждой группе:
+    Возвращает по каждой группе/устройству:
     - total_commands -- общее количество команд
     - toggles_on / toggles_off -- включений / выключений
-    - scenes / colors / brightness / temperature -- количество смен режимов
     - estimated_hours -- оценка часов работы (по парам on/off)
     """
     since = (datetime.now() - timedelta(days=days)).isoformat()
 
     async with async_session() as session:
-        # Все события за период
         result = await session.execute(
             select(EventLog)
             .where(EventLog.timestamp >= since)
@@ -43,10 +41,6 @@ async def get_summary(days: int = Query(default=7, ge=1, le=365)):
                 "total_commands": 0,
                 "toggles_on": 0,
                 "toggles_off": 0,
-                "scenes": 0,
-                "colors": 0,
-                "brightness": 0,
-                "temperature": 0,
                 "estimated_hours": 0.0,
                 "by_user": {},
             }
@@ -58,13 +52,11 @@ async def get_summary(days: int = Query(default=7, ge=1, le=365)):
         u = ev.key_name
         s["by_user"][u] = s["by_user"].get(u, 0) + 1
 
-        # Классификация
         if ev.action == "toggle_on":
             s["toggles_on"] += 1
             last_on[tid] = ev.timestamp
         elif ev.action == "toggle_off":
             s["toggles_off"] += 1
-            # Считаем время работы
             if tid in last_on:
                 try:
                     t_on = datetime.fromisoformat(last_on[tid])
@@ -76,14 +68,18 @@ async def get_summary(days: int = Query(default=7, ge=1, le=365)):
                 except (ValueError, TypeError):
                     pass
                 del last_on[tid]
-        elif ev.action == "scene":
-            s["scenes"] += 1
-        elif ev.action == "color":
-            s["colors"] += 1
-        elif ev.action == "brightness":
-            s["brightness"] += 1
-        elif ev.action == "temperature":
-            s["temperature"] += 1
+
+    # Учитываем незакрытые сессии (лампа ещё включена)
+    now = datetime.now()
+    for tid, ts in last_on.items():
+        if tid in stats:
+            try:
+                t_on = datetime.fromisoformat(ts)
+                delta = (now - t_on).total_seconds() / 3600.0
+                if 0 < delta < 24:
+                    stats[tid]["estimated_hours"] += delta
+            except (ValueError, TypeError):
+                pass
 
     # Округляем часы
     for s in stats.values():