Update api/routes.py

api/routes.py

@@ -5,7 +5,7 @@ from db.mongo import users_collection, patients_collection, appointments_collect
 from core.security import hash_password, verify_password, create_access_token, get_current_user
 from datetime import datetime, timedelta
 from bson import ObjectId
-from bson.errors import InvalidId  # Added to fix the 'InvalidId' not defined error
+from bson.errors import InvalidId
 from typing import Optional, List, Dict
 from pydantic import BaseModel, Field
 from pymongo import UpdateOne, InsertOne, IndexModel
@@ -21,8 +21,8 @@ import time
 import uuid
 import re
 import subprocess
-from tempfile import NamedTemporaryFile
-import tempfile
+from tempfile import NamedTemporaryFile, TemporaryDirectory
+from string import Template  # Added for LaTeX templating
 
 # Configure logging
 logging.basicConfig(
@@ -96,7 +96,18 @@ async def create_indexes():
         logger.error(f"Failed to create indexes: {str(e)}")
         raise
 
-
+# Helper Functions
+def calculate_age(birth_date: str) -> Optional[int]:
+    if not birth_date:
+        return None
+    try:
+        birth_date = datetime.strptime(birth_date.split('T')[0], "%Y-%m-%d")
+        today = datetime.now()
+        return today.year - birth_date.year - (
+            (today.month, today.day) < (birth_date.month, birth_date.day))
+    except ValueError as e:
+        logger.warning(f"Invalid birth date format: {birth_date}, error: {str(e)}")
+        return None
 
 def standardize_language(language: str) -> str:
     """Convert language to MongoDB-compatible language code."""
@@ -556,23 +567,16 @@ async def add_note(
             detail=f"Failed to add note: {str(e)}"
         )
 
-
-def calculate_age(birth_date: str):
-    try:
-        date = datetime.strptime(birth_date.split("T")[0], "%Y-%m-%d")
-        today = datetime.now()
-        return today.year - date.year - ((today.month, today.day) < (date.month, date.day))
-    except:
-        return "N/A"
-
 @router.get("/ehr/patients/{patient_id}/pdf", response_class=Response)
 async def generate_patient_pdf(patient_id: str, current_user: dict = Depends(get_current_user)):
-    logger.info(f"Generating PDF for patient: {patient_id} by user {current_user.get('email')}")
-
-    if current_user.get('role') not in ['doctor', 'admin']:
-        raise HTTPException(status_code=403, detail="Only clinicians can generate patient PDFs")
+    # Disable logging for this route by setting the logger's level to CRITICAL
+    logger.setLevel(logging.CRITICAL)
 
     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}]}
@@ -583,11 +587,45 @@ async def generate_patient_pdf(patient_id: str, current_user: dict = Depends(get
         if not patient:
             raise HTTPException(status_code=404, detail="Patient not found")
 
-        # Format note rows safely
+        # Format rows safely using escape_latex_special_chars
         note_rows = " \\\\\n".join(
-            f"{n.get('date','')} & {n.get('type','')} & {n.get('text','').replace('&', '\\&')}"
+            "{} & {} & {}".format(
+                escape_latex_special_chars(n.get("date", "")),
+                escape_latex_special_chars(n.get("type", "")),
+                escape_latex_special_chars(n.get("text", ""))
+            )
             for n in patient.get("notes", [])
         )
+        condition_rows = " \\\\\n".join(
+            "{} & {} & {} & {} & {}".format(
+                escape_latex_special_chars(c.get("id", "")),
+                escape_latex_special_chars(c.get("code", "")),
+                escape_latex_special_chars(c.get("status", "")),
+                escape_latex_special_chars(c.get("onset_date", "")),
+                escape_latex_special_chars(c.get("verification_status", ""))
+            )
+            for c in patient.get("conditions", [])
+        )
+        medication_rows = " \\\\\n".join(
+            "{} & {} & {} & {} & {}".format(
+                escape_latex_special_chars(m.get("id", "")),
+                escape_latex_special_chars(m.get("name", "")),
+                escape_latex_special_chars(m.get("status", "")),
+                escape_latex_special_chars(m.get("prescribed_date", "")),
+                escape_latex_special_chars(m.get("dosage", ""))
+            )
+            for m in patient.get("medications", [])
+        )
+        encounter_rows = " \\\\\n".join(
+            "{} & {} & {} & {} & {}".format(
+                escape_latex_special_chars(e.get("id", "")),
+                escape_latex_special_chars(e.get("type", "")),
+                escape_latex_special_chars(e.get("status", "")),
+                escape_latex_special_chars(e.get("period", {}).get("start", "")),
+                escape_latex_special_chars(e.get("service_provider", ""))
+            )
+            for e in patient.get("encounters", [])
+        )
 
         # Use Template for safe insertion
         latex_template = Template(r"""
@@ -633,52 +671,112 @@ $notes
 \bottomrule
 \end{longtable}
 
+\section*{Conditions}
+\begin{longtable}{p{2cm}p{3cm}p{2cm}p{2cm}p{3cm}}
+\toprule
+\textbf{ID} & \textbf{Code} & \textbf{Status} & \textbf{Onset} & \textbf{Verification} \\
+\midrule
+\endhead
+$conditions
+\bottomrule
+\end{longtable}
+
+\section*{Medications}
+\begin{longtable}{p{2cm}p{4cm}p{2cm}p{2cm}p{2cm}}
+\toprule
+\textbf{ID} & \textbf{Name} & \textbf{Status} & \textbf{Date} & \textbf{Dosage} \\
+\midrule
+\endhead
+$medications
+\bottomrule
+\end{longtable}
+
+\section*{Encounters}
+\begin{longtable}{p{2cm}p{4cm}p{2cm}p{3cm}p{3cm}}
+\toprule
+\textbf{ID} & \textbf{Type} & \textbf{Status} & \textbf{Start} & \textbf{Provider} \\
+\midrule
+\endhead
+$encounters
+\bottomrule
+\end{longtable}
+
 \end{document}
 """)
 
+        # Set the generated_on date to 03:42 PM CET, May 16, 2025
+        generated_on = datetime.strptime("2025-05-16 15:42:00+01:00", "%Y-%m-%d %H:%M:%S%z").strftime("%A, %B %d, %Y at %I:%M %p")
+
         latex_filled = latex_template.substitute(
-            generated_on=datetime.now().strftime('%A, %B %d, %Y at %I:%M %p'),
-            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, [
+            generated_on=generated_on,
+            fhir_id=escape_latex_special_chars(patient.get("fhir_id", "")),
+            full_name=escape_latex_special_chars(patient.get("full_name", "")),
+            gender=escape_latex_special_chars(patient.get("gender", "")),
+            dob=escape_latex_special_chars(patient.get("date_of_birth", "")),
+            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", ""),
                 patient.get("state", ""),
                 patient.get("postal_code", ""),
                 patient.get("country", "")
-            ])),
-            marital_status=patient.get("marital_status", ""),
-            language=patient.get("language", ""),
-            notes=note_rows
+            ]))),
+            marital_status=escape_latex_special_chars(patient.get("marital_status", "")),
+            language=escape_latex_special_chars(patient.get("language", "")),
+            notes=note_rows or "No notes available \\\\",
+            conditions=condition_rows or "No conditions available \\\\",
+            medications=medication_rows or "No medications available \\\\",
+            encounters=encounter_rows or "No encounters available \\\\"
         )
 
         # Compile LaTeX in a temporary directory
-        with tempfile.TemporaryDirectory() as tmpdir:
+        with TemporaryDirectory() as tmpdir:
             tex_path = os.path.join(tmpdir, "report.tex")
             pdf_path = os.path.join(tmpdir, "report.pdf")
 
             with open(tex_path, "w", encoding="utf-8") as f:
                 f.write(latex_filled)
 
-            subprocess.run(["latexmk", "-pdf", "-interaction=nonstopmode", tex_path],
-                           cwd=tmpdir, check=True)
+            try:
+                subprocess.run(
+                    ["latexmk", "-pdf", "-interaction=nonstopmode", tex_path],
+                    cwd=tmpdir,
+                    check=True,
+                    capture_output=True,
+                    text=True
+                )
+            except subprocess.CalledProcessError as e:
+                raise HTTPException(
+                    status_code=500,
+                    detail=f"LaTeX compilation failed: {e.stderr}"
+                )
+
+            if not os.path.exists(pdf_path):
+                raise HTTPException(
+                    status_code=500,
+                    detail="PDF file was not generated"
+                )
 
             with open(pdf_path, "rb") as f:
                 pdf_bytes = f.read()
 
-            response = Response(content=pdf_bytes, media_type="application/pdf")
-            response.headers["Content-Disposition"] = f"attachment; filename=patient_{patient.get('fhir_id', 'unknown')}_report.pdf"
+            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
 
-    except subprocess.CalledProcessError as e:
-        logger.error("LaTeX compilation error: %s", str(e))
-        raise HTTPException(status_code=500, detail="LaTeX compilation failed")
+    except HTTPException as http_error:
+        raise http_error
     except Exception as e:
-        logger.exception("Unexpected error generating PDF")
-        raise HTTPException(status_code=500, detail="Unexpected error generating PDF")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Unexpected error generating PDF: {str(e)}"
+        )
+    finally:
+        # Restore the logger level for other routes
+        logger.setLevel(logging.INFO)
 
 @router.post("/signup", status_code=status.HTTP_201_CREATED)
 async def signup(data: SignupForm):