329 lines
11 KiB
Python
329 lines
11 KiB
Python
"""
|
|
SLM Dashboard Router
|
|
|
|
Provides API endpoints for the Sound Level Meters dashboard page.
|
|
"""
|
|
|
|
from fastapi import APIRouter, Request, Depends, Query
|
|
from fastapi.templating import Jinja2Templates
|
|
from fastapi.responses import HTMLResponse
|
|
from sqlalchemy.orm import Session
|
|
from sqlalchemy import func
|
|
from datetime import datetime, timedelta
|
|
import httpx
|
|
import logging
|
|
import os
|
|
|
|
from app.seismo.database import get_db
|
|
from app.seismo.models import RosterUnit
|
|
from app.seismo.routers.roster_edit import sync_slm_to_slmm_cache
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
router = APIRouter(prefix="/api/slm-dashboard", tags=["slm-dashboard"])
|
|
templates = Jinja2Templates(directory="templates")
|
|
|
|
# SLMM backend URL - configurable via environment variable
|
|
SLMM_BASE_URL = os.getenv("SLMM_BASE_URL", "http://localhost:8100")
|
|
|
|
|
|
@router.get("/stats", response_class=HTMLResponse)
|
|
async def get_slm_stats(request: Request, db: Session = Depends(get_db)):
|
|
"""
|
|
Get summary statistics for SLM dashboard.
|
|
Returns HTML partial with stat cards.
|
|
"""
|
|
# Query all SLMs
|
|
all_slms = db.query(RosterUnit).filter_by(device_type="sound_level_meter").all()
|
|
|
|
# Count deployed vs benched
|
|
deployed_count = sum(1 for slm in all_slms if slm.deployed and not slm.retired)
|
|
benched_count = sum(1 for slm in all_slms if not slm.deployed and not slm.retired)
|
|
retired_count = sum(1 for slm in all_slms if slm.retired)
|
|
|
|
# Count recently active (checked in last hour)
|
|
one_hour_ago = datetime.utcnow() - timedelta(hours=1)
|
|
active_count = sum(1 for slm in all_slms
|
|
if slm.slm_last_check and slm.slm_last_check > one_hour_ago)
|
|
|
|
return templates.TemplateResponse("partials/slm_stats.html", {
|
|
"request": request,
|
|
"total_count": len(all_slms),
|
|
"deployed_count": deployed_count,
|
|
"benched_count": benched_count,
|
|
"active_count": active_count,
|
|
"retired_count": retired_count
|
|
})
|
|
|
|
|
|
@router.get("/units", response_class=HTMLResponse)
|
|
async def get_slm_units(
|
|
request: Request,
|
|
db: Session = Depends(get_db),
|
|
search: str = Query(None)
|
|
):
|
|
"""
|
|
Get list of SLM units for the sidebar.
|
|
Returns HTML partial with unit cards.
|
|
"""
|
|
query = db.query(RosterUnit).filter_by(device_type="sound_level_meter")
|
|
|
|
# Filter by search term if provided
|
|
if search:
|
|
search_term = f"%{search}%"
|
|
query = query.filter(
|
|
(RosterUnit.id.like(search_term)) |
|
|
(RosterUnit.slm_model.like(search_term)) |
|
|
(RosterUnit.address.like(search_term))
|
|
)
|
|
|
|
# Only show deployed units by default
|
|
units = query.filter_by(deployed=True, retired=False).order_by(RosterUnit.id).all()
|
|
|
|
return templates.TemplateResponse("partials/slm_unit_list.html", {
|
|
"request": request,
|
|
"units": units
|
|
})
|
|
|
|
|
|
@router.get("/live-view/{unit_id}", response_class=HTMLResponse)
|
|
async def get_live_view(request: Request, unit_id: str, db: Session = Depends(get_db)):
|
|
"""
|
|
Get live view panel for a specific SLM unit.
|
|
Returns HTML partial with live metrics and chart.
|
|
"""
|
|
# Get unit from database
|
|
unit = db.query(RosterUnit).filter_by(id=unit_id, device_type="sound_level_meter").first()
|
|
|
|
if not unit:
|
|
return templates.TemplateResponse("partials/slm_live_view_error.html", {
|
|
"request": request,
|
|
"error": f"Unit {unit_id} not found"
|
|
})
|
|
|
|
# Get modem information if assigned
|
|
modem = None
|
|
modem_ip = None
|
|
if unit.deployed_with_modem_id:
|
|
modem = db.query(RosterUnit).filter_by(id=unit.deployed_with_modem_id, device_type="modem").first()
|
|
if modem:
|
|
modem_ip = modem.ip_address
|
|
else:
|
|
logger.warning(f"SLM {unit_id} is assigned to modem {unit.deployed_with_modem_id} but modem not found")
|
|
|
|
# Fallback to direct slm_host if no modem assigned (backward compatibility)
|
|
if not modem_ip and unit.slm_host:
|
|
modem_ip = unit.slm_host
|
|
logger.info(f"Using legacy slm_host for {unit_id}: {modem_ip}")
|
|
|
|
# Try to get current status from SLMM
|
|
current_status = None
|
|
measurement_state = None
|
|
is_measuring = False
|
|
|
|
try:
|
|
async with httpx.AsyncClient(timeout=5.0) as client:
|
|
# Get measurement state
|
|
state_response = await client.get(
|
|
f"{SLMM_BASE_URL}/api/nl43/{unit_id}/measurement-state"
|
|
)
|
|
if state_response.status_code == 200:
|
|
state_data = state_response.json()
|
|
measurement_state = state_data.get("measurement_state", "Unknown")
|
|
is_measuring = state_data.get("is_measuring", False)
|
|
|
|
# Get live status
|
|
status_response = await client.get(
|
|
f"{SLMM_BASE_URL}/api/nl43/{unit_id}/live"
|
|
)
|
|
if status_response.status_code == 200:
|
|
status_data = status_response.json()
|
|
current_status = status_data.get("data", {})
|
|
except Exception as e:
|
|
logger.error(f"Failed to get status for {unit_id}: {e}")
|
|
|
|
return templates.TemplateResponse("partials/slm_live_view.html", {
|
|
"request": request,
|
|
"unit": unit,
|
|
"modem": modem,
|
|
"modem_ip": modem_ip,
|
|
"current_status": current_status,
|
|
"measurement_state": measurement_state,
|
|
"is_measuring": is_measuring
|
|
})
|
|
|
|
|
|
@router.post("/control/{unit_id}/{action}")
|
|
async def control_slm(unit_id: str, action: str):
|
|
"""
|
|
Send control commands to SLM (start, stop, pause, resume, reset).
|
|
Proxies to SLMM backend.
|
|
"""
|
|
valid_actions = ["start", "stop", "pause", "resume", "reset"]
|
|
|
|
if action not in valid_actions:
|
|
return {"status": "error", "detail": f"Invalid action. Must be one of: {valid_actions}"}
|
|
|
|
try:
|
|
async with httpx.AsyncClient(timeout=10.0) as client:
|
|
response = await client.post(
|
|
f"{SLMM_BASE_URL}/api/nl43/{unit_id}/{action}"
|
|
)
|
|
|
|
if response.status_code == 200:
|
|
return response.json()
|
|
else:
|
|
return {
|
|
"status": "error",
|
|
"detail": f"SLMM returned status {response.status_code}"
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Failed to control {unit_id}: {e}")
|
|
return {
|
|
"status": "error",
|
|
"detail": str(e)
|
|
}
|
|
|
|
@router.get("/config/{unit_id}", response_class=HTMLResponse)
|
|
async def get_slm_config(request: Request, unit_id: str, db: Session = Depends(get_db)):
|
|
"""
|
|
Get configuration form for a specific SLM unit.
|
|
Returns HTML partial with configuration form.
|
|
"""
|
|
unit = db.query(RosterUnit).filter_by(id=unit_id, device_type="sound_level_meter").first()
|
|
|
|
if not unit:
|
|
return HTMLResponse(
|
|
content=f'<div class="text-red-500">Unit {unit_id} not found</div>',
|
|
status_code=404
|
|
)
|
|
|
|
return templates.TemplateResponse("partials/slm_config_form.html", {
|
|
"request": request,
|
|
"unit": unit
|
|
})
|
|
|
|
|
|
@router.post("/config/{unit_id}")
|
|
async def save_slm_config(request: Request, unit_id: str, db: Session = Depends(get_db)):
|
|
"""
|
|
Save SLM configuration.
|
|
Updates unit parameters in the database.
|
|
"""
|
|
unit = db.query(RosterUnit).filter_by(id=unit_id, device_type="sound_level_meter").first()
|
|
|
|
if not unit:
|
|
return {"status": "error", "detail": f"Unit {unit_id} not found"}
|
|
|
|
try:
|
|
# Get form data
|
|
form_data = await request.form()
|
|
|
|
# Update SLM-specific fields
|
|
unit.slm_model = form_data.get("slm_model") or None
|
|
unit.slm_serial_number = form_data.get("slm_serial_number") or None
|
|
unit.slm_frequency_weighting = form_data.get("slm_frequency_weighting") or None
|
|
unit.slm_time_weighting = form_data.get("slm_time_weighting") or None
|
|
unit.slm_measurement_range = form_data.get("slm_measurement_range") or None
|
|
|
|
# Update network configuration
|
|
modem_id = form_data.get("deployed_with_modem_id")
|
|
unit.deployed_with_modem_id = modem_id if modem_id else None
|
|
|
|
# Always update TCP and FTP ports (used regardless of modem assignment)
|
|
unit.slm_tcp_port = int(form_data.get("slm_tcp_port")) if form_data.get("slm_tcp_port") else None
|
|
unit.slm_ftp_port = int(form_data.get("slm_ftp_port")) if form_data.get("slm_ftp_port") else None
|
|
|
|
# Only update direct IP if no modem is assigned
|
|
if not modem_id:
|
|
unit.slm_host = form_data.get("slm_host") or None
|
|
else:
|
|
# Clear legacy direct IP field when modem is assigned
|
|
unit.slm_host = None
|
|
|
|
db.commit()
|
|
logger.info(f"Updated configuration for SLM {unit_id}")
|
|
|
|
# Sync updated configuration to SLMM cache
|
|
logger.info(f"Syncing SLM {unit_id} config changes to SLMM cache...")
|
|
result = await sync_slm_to_slmm_cache(
|
|
unit_id=unit_id,
|
|
host=unit.slm_host, # Use the updated host from Terra-View
|
|
tcp_port=unit.slm_tcp_port,
|
|
ftp_port=unit.slm_ftp_port,
|
|
deployed_with_modem_id=unit.deployed_with_modem_id, # Resolve modem IP if assigned
|
|
db=db
|
|
)
|
|
|
|
if not result["success"]:
|
|
logger.warning(f"SLMM cache sync warning for {unit_id}: {result['message']}")
|
|
# Config still saved in Terra-View (source of truth)
|
|
|
|
return {"status": "success", "unit_id": unit_id}
|
|
|
|
except Exception as e:
|
|
db.rollback()
|
|
logger.error(f"Failed to save config for {unit_id}: {e}")
|
|
return {"status": "error", "detail": str(e)}
|
|
|
|
|
|
@router.get("/test-modem/{modem_id}")
|
|
async def test_modem_connection(modem_id: str, db: Session = Depends(get_db)):
|
|
"""
|
|
Test modem connectivity with a simple ping/health check.
|
|
Returns response time and connection status.
|
|
"""
|
|
import subprocess
|
|
import time
|
|
|
|
# Get modem from database
|
|
modem = db.query(RosterUnit).filter_by(id=modem_id, device_type="modem").first()
|
|
|
|
if not modem:
|
|
return {"status": "error", "detail": f"Modem {modem_id} not found"}
|
|
|
|
if not modem.ip_address:
|
|
return {"status": "error", "detail": f"Modem {modem_id} has no IP address configured"}
|
|
|
|
try:
|
|
# Ping the modem (1 packet, 2 second timeout)
|
|
start_time = time.time()
|
|
result = subprocess.run(
|
|
["ping", "-c", "1", "-W", "2", modem.ip_address],
|
|
capture_output=True,
|
|
text=True,
|
|
timeout=3
|
|
)
|
|
response_time = int((time.time() - start_time) * 1000) # Convert to milliseconds
|
|
|
|
if result.returncode == 0:
|
|
return {
|
|
"status": "success",
|
|
"modem_id": modem_id,
|
|
"ip_address": modem.ip_address,
|
|
"response_time": response_time,
|
|
"message": "Modem is responding to ping"
|
|
}
|
|
else:
|
|
return {
|
|
"status": "error",
|
|
"modem_id": modem_id,
|
|
"ip_address": modem.ip_address,
|
|
"detail": "Modem not responding to ping"
|
|
}
|
|
|
|
except subprocess.TimeoutExpired:
|
|
return {
|
|
"status": "error",
|
|
"modem_id": modem_id,
|
|
"ip_address": modem.ip_address,
|
|
"detail": "Ping timeout (> 2 seconds)"
|
|
}
|
|
except Exception as e:
|
|
logger.error(f"Failed to ping modem {modem_id}: {e}")
|
|
return {
|
|
"status": "error",
|
|
"modem_id": modem_id,
|
|
"detail": str(e)
|
|
}
|