Update api/routes/pdf.py

api/routes/pdf.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, HTTPException, Depends, Response
+from fastapi import APIRouter, HTTPException, Depends, BackgroundTasks
 from db.mongo import patients_collection
 from core.security import get_current_user
 from utils.helpers import calculate_age, escape_latex_special_chars, hyphenate_long_strings, format_timestamp
@@ -10,6 +10,13 @@ import subprocess
 from tempfile import TemporaryDirectory
 from string import Template
 import logging
+import asyncio
+import aiohttp
+import json
+from typing import List, Dict, Optional
+from pymongo import MongoClient
+from pymongo.errors import PyMongoError
+from pymongo.change_stream import CollectionChangeStream
 
 # Configure logging
 logging.basicConfig(
@@ -20,26 +27,35 @@ logger = logging.getLogger(__name__)
 
 router = APIRouter()
 
-@router.get("/{patient_id}/pdf", response_class=Response)
-async def generate_patient_pdf(patient_id: str, current_user: dict = Depends(get_current_user)):
-    # Suppress logging for this route
-    logger.setLevel(logging.CRITICAL)
+# Configuration
+FILE_IO_API_URL = "https://file.io"
+FILE_IO_EXPIRATION = "1w"  # 1 week expiration
+PDF_METADATA_COLLECTION = "pdf_metadata"  # Collection to store file.io links
 
+async def upload_to_fileio(file_bytes: bytes, filename: str) -> Optional[Dict]:
+    """Upload a file to file.io and return the response"""
     try:
-        if current_user.get('role') not in ['doctor', 'admin']:
-            raise HTTPException(status_code=403, detail="Only clinicians can generate patient PDFs")
-
-        # Determine if patient_id is ObjectId or fhir_id
-        try:
-            obj_id = ObjectId(patient_id)
-            query = {"$or": [{"_id": obj_id}, {"fhir_id": patient_id}]}
-        except InvalidId:
-            query = {"fhir_id": patient_id}
-
-        patient = await patients_collection.find_one(query)
-        if not patient:
-            raise HTTPException(status_code=404, detail="Patient not found")
+        async with aiohttp.ClientSession() as session:
+            form_data = aiohttp.FormData()
+            form_data.add_field('file', file_bytes, filename=filename)
+            form_data.add_field('expires', FILE_IO_EXPIRATION)
+            
+            async with session.post(FILE_IO_API_URL, data=form_data) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    if data.get('success'):
+                        return data
+                    logger.error(f"File.io upload failed: {data.get('message')}")
+                else:
+                    logger.error(f"File.io upload failed with status {response.status}")
+                return None
+    except Exception as e:
+        logger.error(f"Error uploading to file.io: {str(e)}")
+        return None
 
+async def generate_pdf_bytes(patient: dict) -> Optional[bytes]:
+    """Generate PDF bytes for a patient"""
+    try:
         # Prepare table content with proper LaTeX formatting
         def prepare_table_content(items, columns, default_message):
             if not items:
@@ -54,20 +70,17 @@ async def generate_patient_pdf(patient_id: str, current_user: dict = Depends(get
                 content.append(" & ".join(row) + " \\\\")
             return "\n".join(content)
 
-        # Notes table
-        notes = patient.get("notes", [])
+        # Prepare all table contents
         notes_content = prepare_table_content(
             [{
                 "date": format_timestamp(n.get("date", "")),
                 "type": n.get("type", ""),
                 "text": n.get("text", "")
-            } for n in notes],
+            } for n in patient.get("notes", [])],
             3,
             "No notes available"
         )
 
-        # Conditions table
-        conditions = patient.get("conditions", [])
         conditions_content = prepare_table_content(
             [{
                 "id": c.get("id", ""),
@@ -75,13 +88,11 @@ async def generate_patient_pdf(patient_id: str, current_user: dict = Depends(get
                 "status": c.get("status", ""),
                 "onset": format_timestamp(c.get("onset_date", "")),
                 "verification": c.get("verification_status", "")
-            } for c in conditions],
+            } for c in patient.get("conditions", [])],
             5,
             "No conditions available"
         )
 
-        # Medications table
-        medications = patient.get("medications", [])
         medications_content = prepare_table_content(
             [{
                 "id": m.get("id", ""),
@@ -89,13 +100,11 @@ async def generate_patient_pdf(patient_id: str, current_user: dict = Depends(get
                 "status": m.get("status", ""),
                 "date": format_timestamp(m.get("prescribed_date", "")),
                 "dosage": m.get("dosage", "")
-            } for m in medications],
+            } for m in patient.get("medications", [])],
             5,
             "No medications available"
         )
 
-        # Encounters table
-        encounters = patient.get("encounters", [])
         encounters_content = prepare_table_content(
             [{
                 "id": e.get("id", ""),
@@ -103,12 +112,12 @@ async def generate_patient_pdf(patient_id: str, current_user: dict = Depends(get
                 "status": e.get("status", ""),
                 "start": format_timestamp(e.get("period", {}).get("start", "")),
                 "provider": e.get("service_provider", "")
-            } for e in encounters],
+            } for e in patient.get("encounters", [])],
             5,
             "No encounters available"
         )
 
-        # LaTeX template with improved table formatting
+        # LaTeX template
         latex_template = Template(r"""
 \documentclass[a4paper,12pt]{article}
 \usepackage[utf8]{inputenc}
@@ -181,16 +190,14 @@ $encounters
 \end{document}
 """)
 
-        # Set the generated_on date to 02:54 PM CET, May 17, 2025
-        generated_on = datetime.strptime("2025-05-17 14:54:00+02:00", "%Y-%m-%d %H:%M:%S%z").strftime("%A, %B %d, %Y at %I:%M %p %Z")
-
+        # Fill template with patient data
         latex_filled = latex_template.substitute(
-            generated_on=generated_on,
-            fhir_id=escape_latex_special_chars(hyphenate_long_strings(patient.get("fhir_id", "") or "")),
+            generated_on=datetime.now().strftime("%A, %B %d, %Y at %I:%M %p %Z"),
+            fhir_id=escape_latex_special_chars(hyphenate_long_strings(patient.get("fhir_id", "") or ""),
             full_name=escape_latex_special_chars(patient.get("full_name", "") or ""),
             gender=escape_latex_special_chars(patient.get("gender", "") or ""),
             dob=escape_latex_special_chars(patient.get("date_of_birth", "") or ""),
-            age=escape_latex_special_chars(str(calculate_age(patient.get("date_of_birth", "")) or "N/A")),
+            age=escape_latex_special_chars(str(calculate_age(patient.get("date_of_birth", "")) or "N/A"),
             address=escape_latex_special_chars(", ".join(filter(None, [
                 patient.get("address", ""),
                 patient.get("city", ""),
@@ -206,7 +213,7 @@ $encounters
             encounters=encounters_content
         )
 
-        # Compile LaTeX in a temporary directory
+        # Compile LaTeX to PDF
         with TemporaryDirectory() as tmpdir:
             tex_path = os.path.join(tmpdir, "report.tex")
             pdf_path = os.path.join(tmpdir, "report.pdf")
@@ -214,55 +221,185 @@ $encounters
             with open(tex_path, "w", encoding="utf-8") as f:
                 f.write(latex_filled)
 
-            try:
-                # Run latexmk twice to ensure proper table rendering
-                for _ in range(2):
-                    result = subprocess.run(
-                        ["latexmk", "-pdf", "-interaction=nonstopmode", tex_path],
-                        cwd=tmpdir,
-                        check=False,
-                        capture_output=True,
-                        text=True
-                    )
+            # Run latexmk twice to ensure proper table rendering
+            for _ in range(2):
+                result = subprocess.run(
+                    ["latexmk", "-pdf", "-interaction=nonstopmode", tex_path],
+                    cwd=tmpdir,
+                    check=False,
+                    capture_output=True,
+                    text=True
+                )
                 
                 if result.returncode != 0:
-                    raise HTTPException(
-                        status_code=500,
-                        detail=f"LaTeX compilation failed: stdout={result.stdout}, stderr={result.stderr}"
-                    )
+                    logger.error(f"LaTeX compilation failed: {result.stderr}")
+                    return None
 
-            except subprocess.CalledProcessError as e:
-                raise HTTPException(
-                    status_code=500,
-                    detail=f"LaTeX compilation failed: stdout={e.stdout}, stderr={e.stderr}"
-                )
+            if os.path.exists(pdf_path):
+                with open(pdf_path, "rb") as f:
+                    return f.read()
+            return None
 
-            if not os.path.exists(pdf_path):
-                raise HTTPException(
-                    status_code=500,
-                    detail="PDF file was not generated"
-                )
+    except Exception as e:
+        logger.error(f"Error generating PDF bytes: {str(e)}")
+        return None
+
+async def generate_and_upload_pdf(patient: dict) -> Optional[Dict]:
+    """Generate PDF and upload to file.io, returning metadata"""
+    try:
+        # Generate PDF bytes
+        pdf_bytes = await generate_pdf_bytes(patient)
+        if not pdf_bytes:
+            logger.error(f"Failed to generate PDF for patient {patient.get('fhir_id')}")
+            return None
+
+        # Create filename
+        patient_name = patient.get("full_name", "unknown").replace(" ", "_").lower()
+        patient_id = patient.get("fhir_id", "unknown")
+        filename = f"patient_{patient_id}_{patient_name}_report.pdf"
+
+        # Upload to file.io
+        upload_response = await upload_to_fileio(pdf_bytes, filename)
+        if not upload_response:
+            logger.error(f"Failed to upload PDF for patient {patient.get('fhir_id')}")
+            return None
 
-            with open(pdf_path, "rb") as f:
-                pdf_bytes = f.read()
+        # Prepare metadata
+        metadata = {
+            "patient_id": patient.get("fhir_id"),
+            "patient_name": patient.get("full_name"),
+            "file_key": upload_response.get('key'),
+            "file_url": upload_response.get('link'),
+            "expires_at": upload_response.get('expires'),
+            "generated_at": datetime.utcnow(),
+            "filename": filename
+        }
 
-            response = Response(
-                content=pdf_bytes,
-                media_type="application/pdf",
-                headers={"Content-Disposition": f"attachment; filename=patient_{patient.get('fhir_id', 'unknown')}_report.pdf"}
-            )
-            return response
+        # Store metadata in MongoDB
+        db = patients_collection.database
+        await db[PDF_METADATA_COLLECTION].update_one(
+            {"patient_id": patient.get("fhir_id")},
+            {"$set": metadata},
+            upsert=True
+        )
+
+        logger.info(f"Successfully uploaded PDF for patient {patient.get('fhir_id')}")
+        return metadata
+
+    except Exception as e:
+        logger.error(f"Error in generate_and_upload_pdf: {str(e)}")
+        return None
 
-    except HTTPException as http_error:
-        raise http_error
+async def generate_all_patient_pdfs() -> List[Dict]:
+    """Generate and upload PDFs for all patients"""
+    generated_files = []
+    try:
+        cursor = patients_collection.find({})
+        patients = await cursor.to_list(length=None)
+        
+        if not patients:
+            logger.warning("No patients found in the database")
+            return []
+
+        logger.info(f"Starting PDF generation for {len(patients)} patients")
+        
+        # Process patients in batches
+        batch_size = 5  # Smaller batch size for API rate limiting
+        for i in range(0, len(patients), batch_size):
+            batch = patients[i:i + batch_size]
+            tasks = [generate_and_upload_pdf(patient) for patient in batch]
+            results = await asyncio.gather(*tasks)
+            
+            for result in results:
+                if result:
+                    generated_files.append(result)
+            
+            logger.info(f"Processed batch {i//batch_size + 1}/{(len(patients)-1)//batch_size + 1}")
+            await asyncio.sleep(1)  # Brief pause between batches
+        
+        logger.info(f"Successfully processed {len(generated_files)} patients")
+        return generated_files
+        
+    except Exception as e:
+        logger.error(f"Error in generate_all_patient_pdfs: {str(e)}")
+        return generated_files
+
+async def watch_for_new_patients():
+    """Watch MongoDB change stream for new patients and generate PDFs"""
+    try:
+        logger.info("Starting MongoDB change stream watcher for new patients")
+        
+        # Get the database from the collection
+        db = patients_collection.database
+        
+        # Open a change stream on the patients collection
+        pipeline = [{'$match': {'operationType': 'insert'}}]
+        
+        while True:
+            try:
+                async with patients_collection.watch(pipeline) as stream:
+                    async for change in stream:
+                        try:
+                            patient = change['fullDocument']
+                            logger.info(f"New patient detected: {patient.get('fhir_id')}")
+                            
+                            # Generate and upload PDF
+                            result = await generate_and_upload_pdf(patient)
+                            if result:
+                                logger.info(f"Generated PDF for new patient {patient.get('fhir_id')}")
+                            else:
+                                logger.error(f"Failed to generate PDF for new patient {patient.get('fhir_id')}")
+                                
+                        except Exception as e:
+                            logger.error(f"Error processing change stream event: {str(e)}")
+                            
+            except PyMongoError as e:
+                logger.error(f"MongoDB change stream error: {str(e)}")
+                await asyncio.sleep(5)  # Wait before reconnecting
+                
+    except Exception as e:
+        logger.error(f"Fatal error in watch_for_new_patients: {str(e)}")
+
+@router.on_event("startup")
+async def startup_event():
+    """Start background tasks on application startup"""
+    # Start the change stream watcher
+    asyncio.create_task(watch_for_new_patients())
+
+@router.post("/generate-all-pdfs", status_code=202)
+async def trigger_pdf_generation(
+    background_tasks: BackgroundTasks,
+    current_user: dict = Depends(get_current_user)
+):
+    """Trigger background task to generate PDFs for all patients"""
+    if current_user.get('role') not in ['admin', 'doctor']:
+        raise HTTPException(
+            status_code=403,
+            detail="Only administrators and doctors can generate PDFs"
+        )
+    
+    background_tasks.add_task(generate_all_patient_pdfs)
+    return {"status": "accepted", "message": "PDF generation started in the background"}
+
+@router.get("/list-pdf-links", response_model=List[Dict])
+async def list_pdf_links(current_user: dict = Depends(get_current_user)):
+    """List all stored PDF metadata"""
+    if current_user.get('role') not in ['admin', 'doctor']:
+        raise HTTPException(
+            status_code=403,
+            detail="Only administrators and doctors can list PDFs"
+        )
+    
+    try:
+        db = patients_collection.database
+        cursor = db[PDF_METADATA_COLLECTION].find({})
+        pdfs = await cursor.to_list(length=None)
+        return pdfs
     except Exception as e:
         raise HTTPException(
             status_code=500,
-            detail=f"Unexpected error generating PDF: {str(e)}"
+            detail=f"Error listing PDF files: {str(e)}"
         )
-    finally:
-        # Restore the logger level for other routes
-        logger.setLevel(logging.INFO)
 
 # Export the router as 'pdf' for api.__init__.py
 pdf = router