Update api/routes/pdf.py

api/routes/pdf.py

@@ -5,6 +5,7 @@ from utils.helpers import calculate_age, escape_latex_special_chars, hyphenate_l
 from datetime import datetime
 from bson import ObjectId
 from bson.errors import InvalidId
+import os
 import logging
 import asyncio
 from typing import List, Dict, Optional
@@ -20,109 +21,112 @@ logger = logging.getLogger(__name__)
 router = APIRouter()
 
 # Configuration
-SUMMARY_METADATA_COLLECTION = "patient_summary_json"
+SUMMARY_COLLECTION = "patient_summary_json"
 
-async def generate_patient_summary_json(patient: dict) -> Dict:
-    return {
+async def generate_summary_json(patient: dict) -> Dict:
+    """Generate a structured JSON summary from a patient dict."""
+    summary = {
         "patient_id": patient.get("fhir_id"),
-        "patient_name": patient.get("full_name"),
-        "generated_at": datetime.utcnow(),
-        "summary": {
-            "demographics": {
-                "fhir_id": patient.get("fhir_id"),
-                "full_name": patient.get("full_name"),
-                "gender": patient.get("gender"),
-                "dob": patient.get("date_of_birth"),
-                "age": calculate_age(patient.get("date_of_birth")),
-                "address": ", ".join(filter(None, [
-                    patient.get("address", ""),
-                    patient.get("city", ""),
-                    patient.get("state", ""),
-                    patient.get("postal_code", ""),
-                    patient.get("country", "")
-                ])),
-                "marital_status": patient.get("marital_status"),
-                "language": patient.get("language")
-            },
-            "notes": patient.get("notes", []),
-            "conditions": patient.get("conditions", []),
-            "medications": patient.get("medications", []),
-            "encounters": patient.get("encounters", [])
-        }
+        "full_name": patient.get("full_name"),
+        "gender": patient.get("gender"),
+        "date_of_birth": patient.get("date_of_birth"),
+        "age": calculate_age(patient.get("date_of_birth")),
+        "address": ", ".join(filter(None, [
+            patient.get("address"),
+            patient.get("city"),
+            patient.get("state"),
+            patient.get("postal_code"),
+            patient.get("country")
+        ])),
+        "marital_status": patient.get("marital_status"),
+        "language": patient.get("language"),
+        "notes": patient.get("notes", []),
+        "conditions": patient.get("conditions", []),
+        "medications": patient.get("medications", []),
+        "encounters": patient.get("encounters", []),
+        "generated_at": datetime.utcnow()
     }
+    return summary
 
 async def generate_and_store_summary(patient: dict) -> Optional[Dict]:
+    """Generate and store patient summary JSON in MongoDB."""
     try:
-        summary = await generate_patient_summary_json(patient)
+        summary = await generate_summary_json(patient)
         db = patients_collection.database
-        await db[SUMMARY_METADATA_COLLECTION].update_one(
+        await db[SUMMARY_COLLECTION].update_one(
             {"patient_id": summary["patient_id"]},
             {"$set": summary},
             upsert=True
         )
-        logger.info(f"Stored JSON summary for patient {summary['patient_id']}")
+        logger.info(f"Inserted JSON summary for patient {summary['patient_id']}")
         return summary
     except Exception as e:
-        logger.error(f"Error generating/storing summary: {str(e)}")
+        logger.error(f"Error storing summary for patient {patient.get('fhir_id')}: {str(e)}")
         return None
 
-async def generate_all_patient_summaries() -> List[Dict]:
-    generated = []
+async def generate_all_summaries() -> List[Dict]:
+    """Generate and store summaries for all patients."""
+    results = []
     try:
-        cursor = patients_collection.find({})
-        patients = await cursor.to_list(length=None)
+        patients = await patients_collection.find({}).to_list(length=None)
         for patient in patients:
             summary = await generate_and_store_summary(patient)
             if summary:
-                generated.append(summary)
-        return generated
+                results.append(summary)
+        return results
     except Exception as e:
-        logger.error(f"Error generating all summaries: {str(e)}")
-        return generated
+        logger.error(f"Error in generate_all_summaries: {str(e)}")
+        return results
 
 async def watch_for_new_patients():
+    """Watch MongoDB change stream for new patients and generate summaries."""
     try:
         logger.info("Starting MongoDB change stream for new summaries")
-        db = patients_collection.database
         pipeline = [{'$match': {'operationType': 'insert'}}]
         while True:
             try:
                 async with patients_collection.watch(pipeline) as stream:
                     async for change in stream:
-                        try:
-                            patient = change['fullDocument']
-                            await generate_and_store_summary(patient)
-                        except Exception as e:
-                            logger.error(f"Change stream processing error: {str(e)}")
+                        patient = change['fullDocument']
+                        logger.info(f"New patient detected: {patient.get('fhir_id')}")
+                        await generate_and_store_summary(patient)
             except PyMongoError as e:
-                logger.error(f"MongoDB watch error: {str(e)}")
+                logger.error(f"MongoDB change stream error: {str(e)}")
                 await asyncio.sleep(5)
     except Exception as e:
-        logger.error(f"Fatal error in watcher: {str(e)}")
+        logger.error(f"Fatal error in watch_for_new_patients: {str(e)}")
 
 @router.on_event("startup")
 async def startup_event():
     asyncio.create_task(watch_for_new_patients())
+    asyncio.create_task(generate_all_summaries())
 
-@router.post("/generate-all-summaries", status_code=202)
-async def trigger_summary_generation(
-    background_tasks: BackgroundTasks,
-    current_user: dict = Depends(get_current_user)
-):
+@router.get("/generate-summary/{patient_id}")
+async def generate_summary_for_one(patient_id: str, current_user: dict = Depends(get_current_user)):
     if current_user.get('role') not in ['admin', 'doctor']:
-        raise HTTPException(status_code=403, detail="Only doctors/admins allowed")
-    background_tasks.add_task(generate_all_patient_summaries)
-    return {"status": "accepted", "message": "Summary generation started"}
+        raise HTTPException(status_code=403, detail="Unauthorized")
+
+    try:
+        query = {"fhir_id": patient_id}
+        patient = await patients_collection.find_one(query)
+        if not patient:
+            raise HTTPException(status_code=404, detail="Patient not found")
 
-@router.get("/list-summaries", response_model=List[Dict])
-async def list_summaries(current_user: dict = Depends(get_current_user)):
+        summary = await generate_and_store_summary(patient)
+        return {"status": "success", "summary": summary}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/list-json-summaries", response_model=List[Dict])
+async def list_all_summaries(current_user: dict = Depends(get_current_user)):
     if current_user.get('role') not in ['admin', 'doctor']:
-        raise HTTPException(status_code=403, detail="Only doctors/admins allowed")
+        raise HTTPException(status_code=403, detail="Unauthorized")
+
     try:
         db = patients_collection.database
-        cursor = db[SUMMARY_METADATA_COLLECTION].find({})
-        return await cursor.to_list(length=None)
+        summaries = await db[SUMMARY_COLLECTION].find({}).to_list(length=None)
+        return summaries
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error listing summaries: {str(e)}")
 
-pdf = router
+pdf = router