Update endpoints.py

endpoints.py

@@ -3,45 +3,24 @@ from fastapi.responses import StreamingResponse, JSONResponse
 from fastapi.encoders import jsonable_encoder
 from typing import Optional
 from models import ChatRequest, VoiceOutputRequest, RiskLevel
-from datetime import datetime
-from bson import ObjectId
-import asyncio
-from config import notifications_collection, send_push_notification, decode_access_token, AUTH_SPACE_URL, logger
-import httpx
+from auth import get_current_user
 from utils import clean_text_response
 from analysis import analyze_patient_report
 from voice import recognize_speech, text_to_speech, extract_text_from_pdf
 from docx import Document
 import re
 import io
+from datetime import datetime
+from bson import ObjectId
+import asyncio
+from bson.errors import InvalidId
 
-async def get_current_user(token: str = Depends(lambda: None)):
-    if not token:
-        raise HTTPException(status_code=401, detail="Authorization token required")
-    if token.startswith("Bearer "):
-        token = token.split(" ")[1]
-    payload = decode_access_token(token)
-    if not payload:
-        raise HTTPException(status_code=401, detail="Invalid token")
-    email = payload.get("sub")
-    if not email:
-        raise HTTPException(status_code=401, detail="Invalid token payload")
-
-    # Fetch user from auth Space
-    async with httpx.AsyncClient() as client:
-        headers = {"Authorization": f"Bearer {token}"}
-        response = await client.get(f"{AUTH_SPACE_URL}/me", headers=headers)
-        if response.status_code != 200:
-            raise HTTPException(status_code=response.status_code, detail="Could not validate credentials")
-        user = response.json()
-        return user
-
-def create_router(agent, logger, patients_collection, analysis_collection, users_collection, notifications_collection):
+def create_router(agent, logger, patients_collection, analysis_collection, users_collection):
     router = APIRouter()
 
     @router.get("/status")
     async def status(current_user: dict = Depends(get_current_user)):
-        logger.info(f"Status endpoint accessed by {current_user['email']} at {datetime.utcnow().isoformat()}")
+        logger.info(f"Status endpoint accessed by {current_user['email']}")
         return {
             "status": "running",
             "timestamp": datetime.utcnow().isoformat(),
@@ -54,7 +33,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
         name: Optional[str] = Query(None),
         current_user: dict = Depends(get_current_user)
     ):
-        logger.info(f"Fetching analysis results by {current_user['email']} at {datetime.utcnow().isoformat()}")
+        logger.info(f"Fetching analysis results by {current_user['email']}")
         try:
             query = {}
             if name:
@@ -70,7 +49,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
             for analysis in analyses:
                 patient = await patients_collection.find_one({"fhir_id": analysis.get("patient_id")})
                 if not patient:
-                    continue
+                    continue  # Skip if patient no longer exists
                 analysis["full_name"] = patient.get("full_name", "Unknown")
                 analysis["_id"] = str(analysis["_id"])
                 enriched_results.append(analysis)
@@ -78,31 +57,15 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
             return enriched_results
 
         except Exception as e:
-            logger.error(f"Error fetching analysis results: {str(e)} at {datetime.utcnow().isoformat()}")
+            logger.error(f"Error fetching analysis results: {e}")
             raise HTTPException(status_code=500, detail="Failed to retrieve analysis results")
 
-    @router.get("/notifications")
-    async def get_notifications(current_user: dict = Depends(get_current_user)):
-        logger.info(f"Fetching notifications for {current_user['email']} at {datetime.utcnow().isoformat()}")
-        try:
-            notifications = await notifications_collection.find(
-                {"recipient_email": current_user["email"]}
-            ).sort("timestamp", -1).to_list(length=50)
-            for notification in notifications:
-                notification["_id"] = str(notification["_id"])
-                if "timestamp" in notification:
-                    notification["timestamp"] = notification["timestamp"].isoformat()
-            return notifications
-        except Exception as e:
-            logger.error(f"Error fetching notifications: {str(e)} at {datetime.utcnow().isoformat()}")
-            raise HTTPException(status_code=500, detail="Failed to retrieve notifications")
-
     @router.post("/chat-stream")
     async def chat_stream_endpoint(
         request: ChatRequest,
         current_user: dict = Depends(get_current_user)
     ):
-        logger.info(f"Chat stream initiated by {current_user['email']} at {datetime.utcnow().isoformat()}")
+        logger.info(f"Chat stream initiated by {current_user['email']}")
         async def token_stream():
             try:
                 conversation = [{"role": "system", "content": agent.chat_prompt}]
@@ -128,7 +91,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
                     yield chunk + " "
                     await asyncio.sleep(0.05)
             except Exception as e:
-                logger.error(f"Streaming error: {str(e)} at {datetime.utcnow().isoformat()}")
+                logger.error(f"Streaming error: {e}")
                 yield f"⚠️ Error: {e}"
 
         return StreamingResponse(token_stream(), media_type="text/plain")
@@ -139,7 +102,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
         language: str = Query("en-US", description="Language code for speech recognition"),
         current_user: dict = Depends(get_current_user)
     ):
-        logger.info(f"Voice transcription initiated by {current_user['email']} at {datetime.utcnow().isoformat()}")
+        logger.info(f"Voice transcription initiated by {current_user['email']}")
         try:
             audio_data = await audio.read()
             if not audio.filename.lower().endswith(('.wav', '.mp3', '.ogg', '.flac')):
@@ -151,7 +114,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Error in voice transcription: {str(e)} at {datetime.utcnow().isoformat()}")
+            logger.error(f"Error in voice transcription: {e}")
             raise HTTPException(status_code=500, detail="Error processing voice input")
 
     @router.post("/voice/synthesize")
@@ -159,7 +122,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
         request: VoiceOutputRequest,
         current_user: dict = Depends(get_current_user)
     ):
-        logger.info(f"Voice synthesis initiated by {current_user['email']} at {datetime.utcnow().isoformat()}")
+        logger.info(f"Voice synthesis initiated by {current_user['email']}")
         try:
             audio_data = text_to_speech(request.text, request.language, request.slow)
             
@@ -175,7 +138,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Error in voice synthesis: {str(e)} at {datetime.utcnow().isoformat()}")
+            logger.error(f"Error in voice synthesis: {e}")
             raise HTTPException(status_code=500, detail="Error generating voice output")
 
     @router.post("/voice/chat")
@@ -186,7 +149,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
         max_new_tokens: int = Query(512, ge=50, le=1024),
         current_user: dict = Depends(get_current_user)
     ):
-        logger.info(f"Voice chat initiated by {current_user['email']} at {datetime.utcnow().isoformat()}")
+        logger.info(f"Voice chat initiated by {current_user['email']}")
         try:
             audio_data = await audio.read()
             user_message = recognize_speech(audio_data, language)
@@ -209,7 +172,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Error in voice chat: {str(e)} at {datetime.utcnow().isoformat()}")
+            logger.error(f"Error in voice chat: {e}")
             raise HTTPException(status_code=500, detail="Error processing voice chat")
 
     @router.post("/analyze-report")
@@ -220,7 +183,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
         max_new_tokens: int = Form(1024),
         current_user: dict = Depends(get_current_user)
     ):
-        logger.info(f"Report analysis initiated by {current_user['email']} at {datetime.utcnow().isoformat()}")
+        logger.info(f"Report analysis initiated by {current_user['email']}")
         try:
             content_type = file.content_type
             allowed_types = [
@@ -266,25 +229,6 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
             if "timestamp" in analysis and isinstance(analysis["timestamp"], datetime):
                 analysis["timestamp"] = analysis["timestamp"].isoformat()
 
-            # Check risk level and create notification if moderate or high
-            risk_level = analysis.get("suicide_risk", {}).get("level", "none")
-            risk_score = analysis.get("suicide_risk", {}).get("score", 0)
-            patient = await patients_collection.find_one({"fhir_id": patient_id})
-            patient_name = patient.get("full_name", "Unknown Patient") if patient else "Unknown Patient"
-            if risk_level in ["moderate", "high"]:
-                notification = {
-                    "recipient_email": current_user["email"],
-                    "message": f"Patient {patient_name} has a {risk_level} risk with a score of {int(risk_score * 100)}%",
-                    "patient_id": patient_id,
-                    "risk_level": risk_level,
-                    "timestamp": datetime.utcnow(),
-                    "read": False
-                }
-                await notifications_collection.insert_one(notification)
-                logger.info(f"Notification created for {current_user['email']} at {datetime.utcnow().isoformat()}: {notification['message']}")
-                # Send push notification
-                await send_push_notification(current_user["email"], notification["message"])
-
             return JSONResponse(content=jsonable_encoder({
                 "status": "success",
                 "analysis": analysis,
@@ -296,7 +240,7 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Error in report analysis: {str(e)} at {datetime.utcnow().isoformat()}")
+            logger.error(f"Error in report analysis: {str(e)}")
             raise HTTPException(
                 status_code=500,
                 detail=f"Failed to analyze report: {str(e)}"
@@ -307,30 +251,31 @@ def create_router(agent, logger, patients_collection, analysis_collection, users
         patient_id: str,
         current_user: dict = Depends(get_current_user)
     ):
-        logger.info(f"Patient deletion initiated by {current_user['email']} at {datetime.utcnow().isoformat()} for patient {patient_id}")
+        logger.info(f"Patient deletion initiated by {current_user['email']} for patient {patient_id}")
         try:
+            # Check if the patient exists
             patient = await patients_collection.find_one({"fhir_id": patient_id})
             if not patient:
                 raise HTTPException(status_code=404, detail="Patient not found")
 
+            # Check if the current user is authorized (e.g., created_by matches or is admin)
             if patient.get("created_by") != current_user["email"] and not current_user.get("is_admin", False):
                 raise HTTPException(status_code=403, detail="Not authorized to delete this patient")
 
+            # Delete all analyses associated with this patient
             await analysis_collection.delete_many({"patient_id": patient_id})
-            logger.info(f"Deleted analyses for patient {patient_id} at {datetime.utcnow().isoformat()}")
-
-            await notifications_collection.delete_many({"patient_id": patient_id})
-            logger.info(f"Deleted notifications for patient {patient_id} at {datetime.utcnow().isoformat()}")
+            logger.info(f"Deleted analyses for patient {patient_id}")
 
+            # Delete the patient
             await patients_collection.delete_one({"fhir_id": patient_id})
-            logger.info(f"Patient {patient_id} deleted successfully at {datetime.utcnow().isoformat()}")
+            logger.info(f"Patient {patient_id} deleted successfully")
 
-            return {"status": "success", "message": f"Patient {patient_id} and associated data deleted"}
+            return {"status": "success", "message": f"Patient {patient_id} and associated analyses deleted"}
 
         except HTTPException:
             raise
         except Exception as e:
-            logger.error(f"Error deleting patient {patient_id}: {str(e)} at {datetime.utcnow().isoformat()}")
+            logger.error(f"Error deleting patient {patient_id}: {str(e)}")
             raise HTTPException(status_code=500, detail=f"Failed to delete patient: {str(e)}")
 
     return router