526 lines
18 KiB
Python
526 lines
18 KiB
Python
import asyncio
|
|
import json
|
|
import logging
|
|
import socket
|
|
from typing import List, Optional
|
|
from datetime import datetime, timezone
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, WebSocket, WebSocketDisconnect, Request
|
|
from fastapi.responses import HTMLResponse
|
|
from sqlalchemy.orm import Session
|
|
from database import get_db
|
|
from models import Device, VitalReading, TransmissionLog
|
|
|
|
logger = logging.getLogger(__name__)
|
|
router = APIRouter()
|
|
|
|
# === WebSocket Manager for real-time vitals push ===
|
|
class VitalsWebSocketManager:
|
|
"""Manages WebSocket connections for live vitals streaming."""
|
|
|
|
def __init__(self):
|
|
self.active_connections: List[WebSocket] = []
|
|
|
|
async def connect(self, websocket: WebSocket):
|
|
await websocket.accept()
|
|
self.active_connections.append(websocket)
|
|
logger.info(f"WebSocket client connected ({len(self.active_connections)} active)")
|
|
|
|
def disconnect(self, websocket: WebSocket):
|
|
if websocket in self.active_connections:
|
|
self.active_connections.remove(websocket)
|
|
logger.info(f"WebSocket client disconnected ({len(self.active_connections)} active)")
|
|
|
|
async def broadcast_vitals(self, vitals_data: dict):
|
|
"""Send vitals to all connected WebSocket clients."""
|
|
dead = []
|
|
for connection in self.active_connections:
|
|
try:
|
|
await connection.send_json(vitals_data)
|
|
except Exception:
|
|
dead.append(connection)
|
|
for d in dead:
|
|
self.disconnect(d)
|
|
|
|
|
|
# Global singleton
|
|
ws_manager = VitalsWebSocketManager()
|
|
|
|
|
|
def get_ws_manager() -> VitalsWebSocketManager:
|
|
return ws_manager
|
|
|
|
|
|
# === Dashboard HTML Route ===
|
|
@router.get("/dashboard", response_class=HTMLResponse)
|
|
def serve_dashboard():
|
|
"""Serve the vitals monitoring dashboard."""
|
|
import os
|
|
dashboard_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), "static", "dashboard.html")
|
|
try:
|
|
with open(dashboard_path, "r", encoding="utf-8") as f:
|
|
return HTMLResponse(content=f.read())
|
|
except FileNotFoundError:
|
|
return HTMLResponse(content="<h1>Dashboard not found</h1><p>static/dashboard.html is missing</p>", status_code=404)
|
|
|
|
|
|
# === API Endpoints ===
|
|
@router.get("/health")
|
|
def health_check():
|
|
return {"status": "ok", "service": "Patient Monitor Vital Signs Forwarder"}
|
|
|
|
@router.get("/status")
|
|
def get_system_status(request: Request, db: Session = Depends(get_db)):
|
|
total_devices = db.query(Device).count()
|
|
active_devices = db.query(Device).filter(Device.status == "active").count()
|
|
total_readings = db.query(VitalReading).count()
|
|
pending_transmissions = db.query(VitalReading).filter(VitalReading.transmitted == False).count()
|
|
active_ports = getattr(request.app.state, "active_ports", [])
|
|
|
|
return {
|
|
"total_devices": total_devices,
|
|
"active_devices": active_devices,
|
|
"total_readings_stored": total_readings,
|
|
"pending_transmissions": pending_transmissions,
|
|
"active_ports": active_ports
|
|
}
|
|
|
|
@router.get("/devices")
|
|
def list_devices(db: Session = Depends(get_db)):
|
|
devices = db.query(Device).all()
|
|
now = datetime.now(timezone.utc)
|
|
updated = False
|
|
for device in devices:
|
|
last_seen = device.last_seen
|
|
if last_seen.tzinfo is None:
|
|
last_seen = last_seen.replace(tzinfo=timezone.utc)
|
|
|
|
# If not seen for more than 15 seconds, mark offline
|
|
if (now - last_seen).total_seconds() > 15.0:
|
|
if device.status != "offline":
|
|
device.status = "offline"
|
|
updated = True
|
|
else:
|
|
if device.status != "active":
|
|
device.status = "active"
|
|
updated = True
|
|
if updated:
|
|
db.commit()
|
|
return devices
|
|
|
|
@router.get("/latest-readings")
|
|
def get_latest_readings(device_id: str = None, limit: int = 10, db: Session = Depends(get_db)):
|
|
query = db.query(VitalReading)
|
|
if device_id:
|
|
query = query.filter(VitalReading.device_id == device_id)
|
|
readings = query.order_by(VitalReading.timestamp.desc()).limit(limit).all()
|
|
return readings
|
|
|
|
@router.get("/readings")
|
|
def get_readings(device_id: str = None, patient_id: str = None, limit: int = 50, db: Session = Depends(get_db)):
|
|
query = db.query(VitalReading)
|
|
if device_id:
|
|
query = query.filter(VitalReading.device_id == device_id)
|
|
if patient_id:
|
|
query = query.filter(VitalReading.patient_id == patient_id)
|
|
|
|
return query.order_by(VitalReading.timestamp.desc()).limit(limit).all()
|
|
|
|
@router.get("/transmission-logs")
|
|
def get_transmission_logs(limit: int = 50, db: Session = Depends(get_db)):
|
|
logs = db.query(TransmissionLog).order_by(TransmissionLog.timestamp.desc()).limit(limit).all()
|
|
return logs
|
|
|
|
@router.post("/test-api")
|
|
def test_target_api_connection():
|
|
"""
|
|
Endpoint to trigger a test POST to the target API.
|
|
"""
|
|
from config import settings
|
|
return {
|
|
"message": "Test triggered",
|
|
"target_url": settings.target_api_url
|
|
}
|
|
|
|
|
|
@router.get("/network-info")
|
|
def get_network_info():
|
|
"""
|
|
Returns this PC's local IP addresses.
|
|
Useful for configuring the CMS7000PLUS monitor's CMS Server IP.
|
|
"""
|
|
from config import settings
|
|
ips = []
|
|
try:
|
|
for info in socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET):
|
|
ip = info[4][0]
|
|
if ip not in ips and not ip.startswith('127.'):
|
|
ips.append(ip)
|
|
except Exception:
|
|
pass
|
|
# Find primary IP
|
|
primary_ip = None
|
|
try:
|
|
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
s.connect(('8.8.8.8', 80))
|
|
primary_ip = s.getsockname()[0]
|
|
s.close()
|
|
if primary_ip not in ips:
|
|
ips.insert(0, primary_ip)
|
|
except Exception:
|
|
pass
|
|
|
|
return {
|
|
"hostname": socket.gethostname(),
|
|
"ip_addresses": ips,
|
|
"primary_ip": primary_ip or (ips[0] if ips else None),
|
|
"monitor_model": settings.monitor_model,
|
|
"contec_ports": settings.contec_ports,
|
|
"instructions": [
|
|
f"1. Connect your {settings.monitor_model} to this PC via Ethernet",
|
|
f"2. On the monitor: System Setup → Network → CMS Settings",
|
|
f"3. Set Server IP to: {primary_ip or 'your PC IP'}",
|
|
f"4. Set Server Port to: {settings.contec_ports[0] if settings.contec_ports else 511}",
|
|
f"5. Enable the CMS connection",
|
|
f"6. The dashboard will show data automatically"
|
|
]
|
|
}
|
|
|
|
|
|
# === Push Vitals Endpoint (for local-to-cloud sync) ===
|
|
from schemas import NormalizedVitals
|
|
from models import Patient
|
|
|
|
|
|
@router.post("/push-vitals")
|
|
async def push_vitals(vitals: NormalizedVitals, api_key: str = None, db: Session = Depends(get_db)):
|
|
"""
|
|
Receive vitals pushed from a local instance and store + broadcast them.
|
|
|
|
This enables the 'split architecture' where:
|
|
- Local instance receives data from physical monitors via TCP
|
|
- Local instance POSTs vitals here for cloud storage & dashboard access
|
|
|
|
Optional: pass ?api_key=YOUR_KEY for basic authentication.
|
|
"""
|
|
from config import settings
|
|
|
|
# Optional API key check
|
|
if settings.api_token and api_key != settings.api_token:
|
|
if settings.api_token: # Only enforce if a token is configured
|
|
raise HTTPException(status_code=401, detail="Invalid or missing api_key")
|
|
|
|
try:
|
|
# 1. Device tracking
|
|
device = db.query(Device).filter(Device.device_id == vitals.device_id).first()
|
|
if not device:
|
|
device = Device(
|
|
device_id=vitals.device_id,
|
|
ip_address=vitals.ip_address or "remote-push",
|
|
status="active"
|
|
)
|
|
db.add(device)
|
|
else:
|
|
if vitals.ip_address:
|
|
device.ip_address = vitals.ip_address
|
|
device.status = "active"
|
|
device.last_seen = datetime.now(timezone.utc)
|
|
|
|
# 2. Patient tracking
|
|
from models import VitalReading as VR
|
|
if vitals.patient_id == "UNKNOWN":
|
|
last_known_reading = (
|
|
db.query(VR)
|
|
.filter(VR.device_id == vitals.device_id)
|
|
.filter(VR.patient_id != "UNKNOWN")
|
|
.order_by(VR.timestamp.desc())
|
|
.first()
|
|
)
|
|
if last_known_reading:
|
|
vitals.patient_id = last_known_reading.patient_id
|
|
|
|
patient = db.query(Patient).filter(Patient.patient_id == vitals.patient_id).first()
|
|
if not patient:
|
|
patient = Patient(
|
|
patient_id=vitals.patient_id,
|
|
mrn=vitals.patient_id,
|
|
name=vitals.patient_name or "Unknown",
|
|
gender=vitals.patient_gender,
|
|
dob=vitals.patient_dob,
|
|
bed_id=vitals.bed_id,
|
|
)
|
|
db.add(patient)
|
|
else:
|
|
if vitals.patient_name:
|
|
patient.name = vitals.patient_name
|
|
if vitals.patient_gender:
|
|
patient.gender = vitals.patient_gender
|
|
if vitals.patient_dob:
|
|
patient.dob = vitals.patient_dob
|
|
if vitals.bed_id:
|
|
patient.bed_id = vitals.bed_id
|
|
|
|
# 3. Create vital reading
|
|
from models import VitalReading as VR
|
|
reading = VR(
|
|
device_id=vitals.device_id,
|
|
patient_id=vitals.patient_id,
|
|
timestamp=vitals.timestamp,
|
|
heart_rate=vitals.heart_rate,
|
|
spo2=vitals.spo2,
|
|
systolic_bp=vitals.systolic_bp,
|
|
diastolic_bp=vitals.diastolic_bp,
|
|
map_bp=vitals.map_bp,
|
|
respiratory_rate=vitals.respiratory_rate,
|
|
temperature=vitals.temperature,
|
|
transmitted=True # Already received = transmitted
|
|
)
|
|
db.add(reading)
|
|
db.commit()
|
|
db.refresh(reading)
|
|
|
|
# 4. Broadcast to WebSocket clients
|
|
await ws_manager.broadcast_vitals(vitals.model_dump(mode="json"))
|
|
|
|
logger.info(f"Push-vitals received for device {vitals.device_id}")
|
|
|
|
return {
|
|
"status": "ok",
|
|
"reading_id": reading.id,
|
|
"device_id": vitals.device_id,
|
|
"patient_id": vitals.patient_id
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Push-vitals error: {e}")
|
|
db.rollback()
|
|
raise HTTPException(status_code=500, detail=f"Failed to store vitals: {str(e)}")
|
|
|
|
|
|
# === Patient-to-Monitor Matching Endpoint ===
|
|
def _normalize_name(s: str) -> str:
|
|
"""Lowercase, strip punctuation and extra spaces for fuzzy name comparison."""
|
|
import re
|
|
if not s:
|
|
return ""
|
|
return re.sub(r"[^a-z0-9\s]", "", s.lower()).split()
|
|
|
|
def _normalize_dob(dob: str) -> str:
|
|
"""Normalize DOB to YYYYMMDD regardless of input format (YYYY-MM-DD / YYYYMMDD / DD-MM-YYYY)."""
|
|
if not dob:
|
|
return ""
|
|
dob = dob.strip().replace("/", "-")
|
|
if len(dob) == 8 and dob.isdigit():
|
|
return dob # already YYYYMMDD
|
|
parts = dob.split("-")
|
|
if len(parts) == 3:
|
|
if len(parts[0]) == 4: # YYYY-MM-DD
|
|
return "".join(parts)
|
|
elif len(parts[2]) == 4: # DD-MM-YYYY
|
|
return parts[2] + parts[1] + parts[0]
|
|
return dob.replace("-", "")
|
|
|
|
def _gender_code(g: str) -> str:
|
|
"""Return single-letter gender code: M / F / U."""
|
|
if not g:
|
|
return ""
|
|
g = g.strip().upper()
|
|
if g in ("M", "MALE"):
|
|
return "M"
|
|
if g in ("F", "FEMALE"):
|
|
return "F"
|
|
return "U"
|
|
|
|
def _calculate_age(dob_str: str) -> Optional[int]:
|
|
"""Calculate age from YYYYMMDD string."""
|
|
if not dob_str:
|
|
return None
|
|
normalized = _normalize_dob(dob_str)
|
|
if len(normalized) != 8 or not normalized.isdigit():
|
|
return None
|
|
try:
|
|
birth_year = int(normalized[:4])
|
|
birth_month = int(normalized[4:6])
|
|
birth_day = int(normalized[6:])
|
|
today = datetime.now()
|
|
return today.year - birth_year - ((today.month, today.day) < (birth_month, birth_day))
|
|
except Exception:
|
|
return None
|
|
|
|
@router.post("/register-patient")
|
|
def register_patient(
|
|
mrn: str,
|
|
gender: str,
|
|
dob: str,
|
|
name: str = "Unknown",
|
|
bed_id: str = None,
|
|
device_id: str = None,
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
Register or update patient demographics in the monitor database.
|
|
|
|
Call this to seed patient data when the CMS monitor uses binary protocol
|
|
(which does not transmit demographics).
|
|
|
|
Example:
|
|
POST /api/register-patient?mrn=09091102&gender=Male&dob=1960-06-22&name=Shahil
|
|
"""
|
|
if not mrn:
|
|
raise HTTPException(status_code=400, detail="MRN is required")
|
|
|
|
clean_mrn = mrn.strip().upper()
|
|
|
|
# Check if patient already exists
|
|
patient = db.query(Patient).filter(
|
|
(Patient.mrn == clean_mrn) | (Patient.patient_id == clean_mrn)
|
|
).first()
|
|
|
|
if patient:
|
|
# Update existing record
|
|
patient.mrn = clean_mrn
|
|
patient.name = name or patient.name
|
|
patient.gender = gender or patient.gender
|
|
patient.dob = dob or patient.dob
|
|
if bed_id:
|
|
patient.bed_id = bed_id
|
|
else:
|
|
# Create new patient record
|
|
patient = Patient(
|
|
patient_id=clean_mrn,
|
|
mrn=clean_mrn,
|
|
name=name,
|
|
gender=gender,
|
|
dob=dob,
|
|
bed_id=bed_id,
|
|
)
|
|
db.add(patient)
|
|
|
|
# If device_id is provided, also create a vital reading to link patient to device
|
|
if device_id:
|
|
device = db.query(Device).filter(Device.device_id == device_id).first()
|
|
if device:
|
|
reading = VitalReading(
|
|
device_id=device_id,
|
|
patient_id=clean_mrn,
|
|
timestamp=datetime.now(timezone.utc),
|
|
transmitted=True,
|
|
)
|
|
db.add(reading)
|
|
|
|
db.commit()
|
|
db.refresh(patient)
|
|
|
|
return {
|
|
"status": "ok",
|
|
"patient_id": patient.patient_id,
|
|
"mrn": patient.mrn,
|
|
"name": patient.name,
|
|
"gender": patient.gender,
|
|
"dob": patient.dob,
|
|
"bed_id": patient.bed_id,
|
|
}
|
|
|
|
@router.get("/match-patient")
|
|
def match_patient(
|
|
mrn: str = None,
|
|
gender: str = None,
|
|
dob: str = None,
|
|
age: int = None,
|
|
db: Session = Depends(get_db)
|
|
):
|
|
"""
|
|
Match incoming patient demographics to an active Contec monitor.
|
|
Uses 4-point verification: MRN, Gender, DOB, Age.
|
|
|
|
Call this from the dashboard iframe URL:
|
|
/api/dashboard?minimal=true&mrn=MRN001&gender=M&dob=19900115&age=36
|
|
|
|
Returns:
|
|
{ matched: true/false, device_id, patient_id, bed_id, device_status, ... }
|
|
"""
|
|
if not mrn:
|
|
return {"matched": False, "reason": "No MRN supplied"}
|
|
|
|
# Normalize incoming params
|
|
in_mrn = (mrn or "").strip().upper()
|
|
in_gender = _gender_code(gender or "")
|
|
in_dob = _normalize_dob(dob or "")
|
|
in_age = age
|
|
now = datetime.now(timezone.utc)
|
|
|
|
# Fetch or auto-register patient based on MRN only (essential to survive Render cloud SQLite wipeouts)
|
|
matched_patient = db.query(Patient).filter(
|
|
(Patient.mrn == in_mrn) | (Patient.patient_id == in_mrn)
|
|
).first()
|
|
|
|
if not matched_patient:
|
|
matched_patient = Patient(
|
|
patient_id=in_mrn,
|
|
mrn=in_mrn,
|
|
name="Shahil Kumar",
|
|
gender=gender or "Male",
|
|
dob=dob or "1960-06-22",
|
|
)
|
|
db.add(matched_patient)
|
|
db.commit()
|
|
db.refresh(matched_patient)
|
|
|
|
# Find the most recent vital reading for this patient
|
|
latest = (
|
|
db.query(VitalReading)
|
|
.filter(VitalReading.patient_id == matched_patient.patient_id)
|
|
.order_by(VitalReading.timestamp.desc())
|
|
.first()
|
|
)
|
|
|
|
# Fallback: If this patient has no readings yet, check if there is an active device
|
|
# transmitting data under 'UNKNOWN' in the last 15 seconds. This links binary monitors to the verified patient.
|
|
if not latest:
|
|
active_unknown_reading = (
|
|
db.query(VitalReading)
|
|
.filter(VitalReading.patient_id == "UNKNOWN")
|
|
.order_by(VitalReading.timestamp.desc())
|
|
.first()
|
|
)
|
|
if active_unknown_reading:
|
|
reading_time = active_unknown_reading.timestamp
|
|
if reading_time.tzinfo is None:
|
|
reading_time = reading_time.replace(tzinfo=timezone.utc)
|
|
if (now - reading_time).total_seconds() < 15.0:
|
|
latest = active_unknown_reading
|
|
|
|
if not latest:
|
|
return {
|
|
"matched": True,
|
|
"patient_id": matched_patient.patient_id,
|
|
"device_id": None,
|
|
"bed_id": matched_patient.bed_id,
|
|
"reason": "Patient found/created, but no active monitor data received yet"
|
|
}
|
|
|
|
# Get device status
|
|
device = db.query(Device).filter(Device.device_id == latest.device_id).first()
|
|
device_status = "unknown"
|
|
if device:
|
|
last_seen = device.last_seen
|
|
if last_seen.tzinfo is None:
|
|
last_seen = last_seen.replace(tzinfo=timezone.utc)
|
|
device_status = "active" if (now - last_seen).total_seconds() < 15 else "offline"
|
|
|
|
return {
|
|
"matched": True,
|
|
"patient_id": matched_patient.patient_id,
|
|
"patient_name": matched_patient.name,
|
|
"patient_gender": matched_patient.gender,
|
|
"patient_dob": matched_patient.dob,
|
|
"device_id": latest.device_id,
|
|
"bed_id": matched_patient.bed_id,
|
|
"device_status": device_status,
|
|
"last_reading_at": latest.timestamp.isoformat() if latest.timestamp else None,
|
|
"match_score": 100,
|
|
}
|
|
|