Update api/routes.py

api/routes.py

@@ -1,16 +1,15 @@
-from fastapi import APIRouter, HTTPException, Depends
+from fastapi import APIRouter, HTTPException, Depends, Body
 from fastapi.security import OAuth2PasswordRequestForm
 from models.schemas import SignupForm, TokenResponse, PatientCreate, DoctorCreate, AppointmentCreate
 from db.mongo import users_collection, patients_collection, appointments_collection
 from core.security import hash_password, verify_password, create_access_token, get_current_user
 from datetime import datetime
 from bson import ObjectId
-from typing import Optional
-from pymongo import UpdateOne
-import json
-from pathlib import Path
-import traceback
+from bson.errors import InvalidId
+from typing import Optional, List
+from pydantic import BaseModel
 import httpx
+from pymongo import UpdateOne
 
 router = APIRouter()
 
@@ -56,6 +55,22 @@ async def create_doctor(data: DoctorCreate):
     await users_collection.insert_one(user_doc)
     return {"success": True, "message": "Doctor account created"}
 
+# --- GET ALL DOCTORS ---
+@router.get("/doctors")
+async def list_doctors():
+    cursor = users_collection.find({"role": "doctor"})
+    doctors = []
+    async for doc in cursor:
+        doctors.append({
+            "id": str(doc["_id"]),
+            "full_name": doc.get("full_name", ""),
+            "email": doc.get("email", ""),
+            "matricule": doc.get("matricule", ""),
+            "specialty": doc.get("specialty", ""),
+            "created_at": doc.get("created_at"),
+        })
+    return doctors
+
 # --- LOGIN ---
 @router.post("/login", response_model=TokenResponse)
 async def login(form_data: OAuth2PasswordRequestForm = Depends()):
@@ -83,59 +98,101 @@ async def get_me(current_user: dict = Depends(get_current_user)):
         "created_at": user.get("created_at", "")
     }
 
-# --- IMPORT MOCKED FHIR PATIENTS ---
+# --- ADD NEW PATIENT ---
+@router.post("/patients")
+async def add_patient(data: PatientCreate, current_user: dict = Depends(get_current_user)):
+    if current_user.get("role") != "doctor":
+        raise HTTPException(status_code=403, detail="Only doctors can add patients")
+
+    patient_doc = {
+        **data.dict(),
+        "date_of_birth": datetime.combine(data.date_of_birth, datetime.min.time()),
+        "contact": data.contact.dict() if data.contact else {},
+        "created_by": current_user["email"],
+        "created_at": datetime.utcnow()
+    }
+    result = await patients_collection.insert_one(patient_doc)
+    return {"id": str(result.inserted_id), "message": "Patient created successfully"}
+
+# --- GET ALL PATIENTS ---
+@router.get("/patients")
+async def list_patients(current_user: dict = Depends(get_current_user)):
+    if current_user.get("role") != "doctor":
+        raise HTTPException(status_code=403, detail="Only doctors can view patients")
+
+    cursor = patients_collection.find({"created_by": current_user["email"]})
+    patients = []
+    async for p in cursor:
+        patients.append({
+            "id": str(p["_id"]),
+            "full_name": p.get("full_name", ""),
+            "date_of_birth": p.get("date_of_birth"),
+            "gender": p.get("gender", ""),
+            "notes": p.get("notes", "")
+        })
+    return patients
+
+# --- IMPORT FROM PUBLIC FHIR API ---
+
 @router.post("/ehr/fetch-from-api")
 async def fetch_and_store_patients_from_fhir():
-    base_url = "https://launch.smarthealthit.org/v/r4/fhir"
-    patient_url = f"{base_url}/Patient?_count=50"
-    valid_patients = []
+    fhir_patients_url = "https://hapi.fhir.org/baseR4/Patient?_count=50"
+    fhir_encounters_url = "https://hapi.fhir.org/baseR4/Encounter?_count=100"
 
     try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            patient_response = await client.get(patient_url)
-
-        if patient_response.status_code != 200:
-            raise HTTPException(status_code=502, detail="Failed to fetch patients")
+        async with httpx.AsyncClient() as client:
+            # Fetch patients
+            patient_res = await client.get(fhir_patients_url)
+            if patient_res.status_code != 200:
+                raise HTTPException(status_code=502, detail="Failed to fetch patients")
+            patient_entries = patient_res.json().get("entry", [])
+
+            # Fetch encounters
+            encounter_res = await client.get(fhir_encounters_url)
+            if encounter_res.status_code != 200:
+                raise HTTPException(status_code=502, detail="Failed to fetch encounters")
+            encounter_entries = encounter_res.json().get("entry", [])
+
+        # Parse encounter notes grouped by patient ID
+        patient_notes = {}
+        for entry in encounter_entries:
+            resource = entry.get("resource", {})
+            ref = resource.get("subject", {}).get("reference")  # e.g., "Patient/abc123"
+            if not ref or "note" not in resource:
+                continue
 
-        patients_data = patient_response.json().get("entry", [])
+            patient_id = ref.split("/")[-1]
+            notes_texts = [n.get("text") for n in resource.get("note", []) if n.get("text")]
+            if notes_texts:
+                patient_notes.setdefault(patient_id, []).extend(notes_texts)
 
-        for p_entry in patients_data:
-            resource = p_entry.get("resource", {})
+        operations = []
+        for entry in patient_entries:
+            resource = entry.get("resource", {})
             fhir_id = resource.get("id")
-            name_data = resource.get("name", [{}])[0]
-            full_name = f"{name_data.get('given', [''])[0]} {name_data.get('family', '')}".strip()
+            name_info = resource.get("name", [{}])[0]
+            address_info = resource.get("address", [{}])[0]
+
+            given = name_info.get("given", [""])[0]
+            family = name_info.get("family", "")
+            full_name = f"{given} {family}".strip()
+
             gender = resource.get("gender")
             birth_date = resource.get("birthDate")
+            address = address_info.get("line", [""])[0]
+            city = address_info.get("city", "")
+            state = address_info.get("state", "")
+            zip_code = address_info.get("postalCode", "")
 
-            address_data = resource.get("address", [{}])[0]
-            address = address_data.get("line", [""])[0] if "line" in address_data else ""
-            city = address_data.get("city", "")
-            state = address_data.get("state", "")
-            zip_code = address_data.get("postalCode", "")
-
-            # Ensure required fields are present
+            # Skip if any essential field is missing
             if not all([fhir_id, full_name, gender, birth_date, address, city, state, zip_code]):
                 continue
 
-            # Fetch encounters with notes
-            try:
-                async with httpx.AsyncClient(timeout=20.0) as client:
-                    enc_response = await client.get(f"{base_url}/Encounter?subject=Patient/{fhir_id}")
+            notes = patient_notes.get(fhir_id, [])
 
-                encounter_entries = enc_response.json().get("entry", []) if enc_response.status_code == 200 else []
-                notes = []
-
-                for enc in encounter_entries:
-                    enc_res = enc.get("resource", {})
-                    for note in enc_res.get("note", []):
-                        text = note.get("text")
-                        if text:
-                            notes.append(text)
-
-                if not notes:
-                    continue  # Skip if no notes
-
-                valid_patients.append({
+            operations.append(UpdateOne(
+                {"fhir_id": fhir_id},
+                {"$set": {
                     "fhir_id": fhir_id,
                     "full_name": full_name,
                     "gender": gender,
@@ -146,27 +203,22 @@ async def fetch_and_store_patients_from_fhir():
                     "zip": zip_code,
                     "notes": notes,
                     "created_at": datetime.utcnow()
-                })
+                }},
+                upsert=True
+            ))
 
-            except Exception as enc_err:
-                print(f"Skipping encounter fetch error for {fhir_id}: {enc_err}")
-                continue
+        if operations:
+            result = await patients_collection.bulk_write(operations)
+            return {
+                "message": "Fetched and stored patients with linked notes successfully",
+                "inserted": result.upserted_count,
+                "modified": result.modified_count
+            }
 
-        if not valid_patients:
-            return {"message": "No valid patients found with complete data and notes."}
-
-        result = await patients_collection.insert_many(valid_patients)
-        return {
-            "message": "Imported valid patients with notes",
-            "count": len(result.inserted_ids)
-        }
+        return {"message": "No valid patients to store"}
 
     except Exception as e:
-        print("❌ Server-side error during FHIR import:", e)
-        raise HTTPException(status_code=500, detail="Server error during patient import.")
-
-
-# --- GET FHIR PATIENTS ---
+        raise HTTPException(status_code=500, detail=str(e))
 @router.get("/ehr/fhir-patients")
 async def list_fhir_patients():
     cursor = patients_collection.find({"fhir_id": {"$exists": True}})
@@ -177,6 +229,5 @@ async def list_fhir_patients():
             "full_name": p.get("full_name"),
             "gender": p.get("gender"),
             "date_of_birth": p.get("date_of_birth"),
-            "notes": p.get("notes", [])
         })
     return patients