Update api/routes/patients.py

api/routes/patients.py

@@ -7,7 +7,7 @@ from models.entities import Note, PatientCreate
 from datetime import datetime
 from bson import ObjectId
 from bson.errors import InvalidId
-from typing import Optional, List, Dict
+from typing import Optional, List, Dict, Any
 from pymongo import UpdateOne, DeleteOne
 from pymongo.errors import BulkWriteError
 import json
@@ -18,6 +18,7 @@ import re
 import logging
 import time
 import os
+from pydantic import BaseModel, Field
 
 # Configure logging
 logging.basicConfig(
@@ -33,6 +34,54 @@ BASE_DIR = Path(__file__).resolve().parent.parent.parent
 SYNTHEA_DATA_DIR = BASE_DIR / "output" / "fhir"
 os.makedirs(SYNTHEA_DATA_DIR, exist_ok=True)
 
+# Pydantic models for update validation
+class ConditionUpdate(BaseModel):
+    id: Optional[str] = None
+    code: Optional[str] = None
+    status: Optional[str] = None
+    onset_date: Optional[str] = None
+    recorded_date: Optional[str] = None
+    verification_status: Optional[str] = None
+    notes: Optional[str] = None
+
+class MedicationUpdate(BaseModel):
+    id: Optional[str] = None
+    name: Optional[str] = None
+    status: Optional[str] = None
+    prescribed_date: Optional[str] = None
+    requester: Optional[str] = None
+    dosage: Optional[str] = None
+
+class EncounterUpdate(BaseModel):
+    id: Optional[str] = None
+    type: Optional[str] = None
+    status: Optional[str] = None
+    period: Optional[Dict[str, str]] = None
+    service_provider: Optional[str] = None
+
+class NoteUpdate(BaseModel):
+    id: Optional[str] = None
+    title: Optional[str] = None
+    date: Optional[str] = None
+    author: Optional[str] = None
+    content: Optional[str] = None
+
+class PatientUpdate(BaseModel):
+    full_name: Optional[str] = None
+    gender: Optional[str] = None
+    date_of_birth: Optional[str] = None
+    address: Optional[str] = None
+    city: Optional[str] = None
+    state: Optional[str] = None
+    postal_code: Optional[str] = None
+    country: Optional[str] = None
+    marital_status: Optional[str] = None
+    language: Optional[str] = None
+    conditions: Optional[List[ConditionUpdate]] = None
+    medications: Optional[List[MedicationUpdate]] = None
+    encounters: Optional[List[EncounterUpdate]] = None
+    notes: Optional[List[NoteUpdate]] = None
+
 @router.get("/debug/count")
 async def debug_patient_count():
     """Debug endpoint to verify patient counts"""
@@ -172,6 +221,7 @@ async def delete_patient(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=f"Failed to delete patient: {str(e)}"
         )
+
 async def process_synthea_patient(bundle: dict, file_path: str) -> Optional[dict]:
     logger.debug(f"Processing patient from file: {file_path}")
     patient_data = {}
@@ -424,7 +474,7 @@ async def list_patients(
     skip: int = Query(0, ge=0)
 ):
     logger.info(f"Listing patients with search: {search}, limit: {limit}, skip: {skip}")
-    query = {}  # Removed the default "source": "synthea" filter
+    query = {}
     
     if search:
         query["$or"] = [
@@ -449,7 +499,7 @@ async def list_patients(
         "medications": 1,
         "encounters": 1,
         "notes": 1,
-        "source": 1  # Added source to projection
+        "source": 1
     }
     
     try:
@@ -608,5 +658,170 @@ async def add_note(
             detail=f"Failed to add note: {str(e)}"
         )
 
+@router.put("/patients/{patient_id}", status_code=status.HTTP_200_OK)
+async def update_patient(
+    patient_id: str,
+    update_data: PatientUpdate,
+    current_user: dict = Depends(get_current_user)
+):
+    """Update a patient's record in the database"""
+    logger.info(f"Updating patient {patient_id} by user {current_user.get('email')}")
+    
+    if current_user.get('role') not in ['admin', 'doctor']:
+        logger.warning(f"Unauthorized update attempt by {current_user.get('email')}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only administrators and doctors can update patients"
+        )
+    
+    try:
+        # Build the query based on whether patient_id is a valid ObjectId
+        query = {"fhir_id": patient_id}
+        if ObjectId.is_valid(patient_id):
+            query = {
+                "$or": [
+                    {"_id": ObjectId(patient_id)},
+                    {"fhir_id": patient_id}
+                ]
+            }
+        
+        # Check if patient exists
+        patient = await patients_collection.find_one(query)
+        if not patient:
+            logger.warning(f"Patient not found for update: {patient_id}")
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Patient not found"
+            )
+        
+        # Prepare update operations
+        update_ops = {"$set": {"last_updated": datetime.utcnow().isoformat()}}
+        
+        # Handle demographic updates
+        demographics = {
+            "full_name": update_data.full_name,
+            "gender": update_data.gender,
+            "date_of_birth": update_data.date_of_birth,
+            "address": update_data.address,
+            "city": update_data.city,
+            "state": update_data.state,
+            "postal_code": update_data.postal_code,
+            "country": update_data.country,
+            "marital_status": update_data.marital_status,
+            "language": update_data.language
+        }
+        for key, value in demographics.items():
+            if value is not None:
+                update_ops["$set"][key] = value
+        
+        # Handle array updates (conditions, medications, encounters, notes)
+        array_fields = {
+            "conditions": update_data.conditions,
+            "medications": update_data.medications,
+            "encounters": update_data.encounters,
+            "notes": update_data.notes
+        }
+        
+        for field, items in array_fields.items():
+            if items is not None:
+                # Fetch existing items
+                existing_items = patient.get(field, [])
+                updated_items = []
+                
+                for item in items:
+                    item_dict = item.dict(exclude_unset=True)
+                    if not item_dict:
+                        continue
+                    
+                    # Generate ID for new items
+                    if not item_dict.get("id"):
+                        item_dict["id"] = str(uuid.uuid4())
+                    
+                    # Validate required fields
+                    if field == "conditions" and not item_dict.get("code"):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"Condition code is required for {field}"
+                        )
+                    if field == "medications" and not item_dict.get("name"):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"Medication name is required for {field}"
+                        )
+                    if field == "encounters" and not item_dict.get("type"):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"Encounter type is required for {field}"
+                        )
+                    if field == "notes" and not item_dict.get("content"):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"Note content is required for {field}"
+                        )
+                    
+                    updated_items.append(item_dict)
+                
+                # Replace the entire array
+                update_ops["$set"][field] = updated_items
+        
+        # Perform the update
+        result = await patients_collection.update_one(query, update_ops)
+        
+        if result.modified_count == 0 and result.matched_count == 0:
+            logger.warning(f"Patient not found for update: {patient_id}")
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Patient not found"
+            )
+        
+        # Retrieve and return the updated patient
+        updated_patient = await patients_collection.find_one(query)
+        if not updated_patient:
+            logger.error(f"Failed to retrieve updated patient: {patient_id}")
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail="Failed to retrieve updated patient"
+            )
+        
+        response = {
+            "id": str(updated_patient["_id"]),
+            "fhir_id": updated_patient.get("fhir_id"),
+            "full_name": updated_patient.get("full_name"),
+            "gender": updated_patient.get("gender"),
+            "date_of_birth": updated_patient.get("date_of_birth"),
+            "address": updated_patient.get("address"),
+            "city": updated_patient.get("city"),
+            "state": updated_patient.get("state"),
+            "postal_code": updated_patient.get("postal_code"),
+            "country": updated_patient.get("country"),
+            "marital_status": updated_patient.get("marital_status"),
+            "language": updated_patient.get("language"),
+            "conditions": updated_patient.get("conditions", []),
+            "medications": updated_patient.get("medications", []),
+            "encounters": updated_patient.get("encounters", []),
+            "notes": updated_patient.get("notes", []),
+            "source": updated_patient.get("source"),
+            "import_date": updated_patient.get("import_date"),
+            "last_updated": updated_patient.get("last_updated")
+        }
+        
+        logger.info(f"Successfully updated patient {patient_id}")
+        return response
+        
+    except ValueError as ve:
+        logger.error(f"Invalid patient ID format: {patient_id}, error: {str(ve)}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid patient ID format"
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to update patient {patient_id}: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to update patient: {str(e)}"
+        )
+
 # Export the router as 'patients' for api.__init__.py
 patients = router