teest

analysis.py

@@ -1,6 +1,7 @@
 from typing import Optional, Tuple, List
 from enum import Enum
 from config import agent, patients_collection, analysis_collection, alerts_collection, logger
+from db.mongo import users_collection, notifications_collection
 from models import RiskLevel
 from utils import (
     structure_medical_response, 
@@ -26,6 +27,10 @@ class NotificationStatus(str, Enum):
 
 async def create_alert(patient_id: str, risk_data: dict):
     try:
+        # Get patient information for better notification message
+        patient = await patients_collection.find_one({"fhir_id": patient_id})
+        patient_name = patient.get("full_name", "Unknown Patient") if patient else "Unknown Patient"
+        
         alert_doc = {
             "patient_id": patient_id,
             "type": "suicide_risk",
@@ -38,7 +43,7 @@ async def create_alert(patient_id: str, risk_data: dict):
                 "type": "risk_alert",
                 "status": "unread",
                 "title": f"Suicide Risk: {risk_data['level'].capitalize()}",
-                "message": f"Patient {patient_id} shows {risk_data['level']} risk factors",
+                "message": f"Patient {patient_name} ({patient_id}) shows {risk_data['level']} risk factors",
                 "icon": "⚠️",
                 "action_url": f"/patient/{patient_id}/risk-assessment",
                 "priority": "high" if risk_data["level"] in ["high", "severe"] else "medium"
@@ -47,10 +52,43 @@ async def create_alert(patient_id: str, risk_data: dict):
         
         await alerts_collection.insert_one(alert_doc)
         
+        # Create notifications for all doctors and admins when risk is high or moderate
+        if risk_data["level"] in ["high", "moderate", "severe"]:
+            # Get all users with doctor or admin roles
+            doctors_and_admins = await users_collection.find({
+                "roles": {"$in": ["doctor", "admin"]}
+            }).to_list(length=None)
+            
+            logger.info(f"📧 Creating notifications for {len(doctors_and_admins)} doctors/admins")
+            
+            # Create individual notifications for each doctor/admin
+            notifications = []
+            for user in doctors_and_admins:
+                notification = {
+                    "user_id": user["email"],
+                    "patient_id": patient_id,
+                    "message": f"🚨 {risk_data['level'].upper()} suicide risk detected for patient {patient_name}",
+                    "timestamp": datetime.utcnow(),
+                    "severity": "high" if risk_data["level"] in ["high", "severe"] else "medium",
+                    "read": False,
+                    "type": "suicide_risk_alert",
+                    "risk_level": risk_data["level"],
+                    "risk_score": risk_data["score"],
+                    "patient_name": patient_name
+                }
+                notifications.append(notification)
+            
+            if notifications:
+                # Insert all notifications at once
+                result = await notifications_collection.insert_many(notifications)
+                logger.info(f"✅ Created {len(result.inserted_ids)} notifications for risk alert")
+            else:
+                logger.warning("⚠️ No doctors or admins found to notify")
+        
         # Simplified WebSocket notification - remove Hugging Face specific code
         await broadcast_notification(alert_doc["notification"])
         
-        logger.warning(f"⚠️ Created suicide risk alert for patient {patient_id}")
+        logger.warning(f"⚠️ Created suicide risk alert for patient {patient_id} ({patient_name}) - Level: {risk_data['level']}")
         return alert_doc
     except Exception as e:
         logger.error(f"Failed to create alert: {str(e)}")
@@ -164,7 +202,16 @@ async def analyze_patient(patient: dict):
             return
 
         # Generate analysis
-        doc = json.dumps(serialized, indent=2)
+        # Custom JSON encoder to handle datetime objects
+        class DateTimeEncoder(json.JSONEncoder):
+            def default(self, obj):
+                if isinstance(obj, datetime):
+                    return obj.isoformat()
+                elif hasattr(obj, '__dict__'):
+                    return obj.__dict__
+                return super().default(obj)
+        
+        doc = json.dumps(serialized, indent=2, cls=DateTimeEncoder)
         message = (
             "You are a clinical decision support AI.\n\n"
             "Given the patient document below:\n"

api/__init__.py

@@ -17,7 +17,7 @@ def get_router():
     from .routes.pdf import pdf
     from .routes.appointments import router as appointments
     from .routes.messaging import router as messaging
-    from .routes.txagent import router as txagent, get_txagent, ChatRequest
+    # from .routes.txagent import router as txagent, get_txagent, ChatRequest  # Commented out - using separate TxAgent API
     from fastapi import Depends, HTTPException, UploadFile, File
     from core.security import get_current_user
     import asyncio
@@ -31,161 +31,159 @@ def get_router():
     router.include_router(pdf, prefix="/patients", tags=["pdf"])  # Keep prefix for PDF routes
     router.include_router(appointments, prefix="/appointments", tags=["appointments"])
     router.include_router(messaging, tags=["messaging"])
-    router.include_router(txagent, tags=["txagent"])
+    # router.include_router(txagent, tags=["txagent"])  # Commented out - using separate TxAgent API
     
-    # Add the chat-stream endpoint at the root level
-    @router.post("/chat-stream")
-    async def chat_stream(
-        request: ChatRequest,
-        current_user: dict = Depends(get_current_user)
-    ):
-        """Streaming chat endpoint for TxAgent"""
-        import logging
-        logger = logging.getLogger(__name__)
-        
-        try:
-            if not any(role in current_user.get('roles', []) for role in ['doctor', 'admin']):
-                raise HTTPException(status_code=403, detail="Only doctors and admins can use TxAgent")
+    # TxAgent endpoints commented out - using separate TxAgent API
+    # @router.post("/chat-stream")
+    # async def chat_stream(
+    #     request: ChatRequest,
+    #     current_user: dict = Depends(get_current_user)
+    # ):
+    #     """Streaming chat endpoint for TxAgent"""
+    #     import logging
+    #     logger = logging.getLogger(__name__)
+    #     
+    #     try:
+    #         if not any(role in current_user.get('roles', []) for role in ['doctor', 'admin']):
+    #             raise HTTPException(status_code=403, detail="Only doctors and admins can use TxAgent")
 
-            # Get TxAgent instance
-            txagent = get_txagent()
-            
-            if txagent is None:
-                # Fallback response if TxAgent is not available
-                response_text = f"TxAgent is currently unavailable. Please try again later. Your message was: {request.message}"
-            else:
-                # Get real response from TxAgent
-                try:
-                    response_text = txagent.chat(
-                        message=request.message,
-                        temperature=request.temperature,
-                        max_new_tokens=request.max_new_tokens
-                    )
-                except Exception as e:
-                    logger.error(f"TxAgent chat failed: {e}")
-                    response_text = f"Sorry, I encountered an error processing your request: {request.message}. Please try again."
+    #         # Get TxAgent instance
+    #         txagent = get_txagent()
+    #         
+    #         if txagent is None:
+    #             # Fallback response if TxAgent is not available
+    #             response_text = f"TxAgent is currently unavailable. Please try again later. Your message was: {request.message}"
+    #         else:
+    #             # Get real response from TxAgent
+    #             try:
+    #                 response_text = txagent.chat(
+    #                     message=request.message,
+    #                     temperature=request.temperature,
+    #                     max_new_tokens=request.max_new_tokens
+    #                 )
+    #             except Exception as e:
+    #                 logger.error(f"TxAgent chat failed: {e}")
+    #                 response_text = f"Sorry, I encountered an error processing your request: {request.message}. Please try again."
 
-            # Return streaming text without data: prefix
-            async def generate():
-                # Send the complete response as plain text
-                yield response_text
+    #         # Return streaming text without data: prefix
+    #         async def generate():
+    #             # Send the complete response as plain text
+    #             yield response_text
 
-            return StreamingResponse(
-                generate(),
-                media_type="text/plain",
-                headers={
-                    "Cache-Control": "no-cache",
-                    "Connection": "keep-alive"
-                }
-            )
-        except Exception as e:
-            logger.error(f"Error in chat stream: {e}")
-            raise HTTPException(status_code=500, detail="Failed to process chat stream")
+    #         return StreamingResponse(
+    #             generate(),
+    #             media_type="text/plain",
+    #             headers={
+    #                 "Cache-Control": "no-cache",
+    #                 "Connection": "keep-alive"
+    #             }
+    #         )
+    #     except Exception as e:
+    #         logger.error(f"Error in chat stream: {e}")
+    #         raise HTTPException(status_code=500, detail="Failed to process chat stream")
     
-    # Add voice synthesis endpoint at the root level for frontend compatibility
-    @router.post("/voice/synthesize")
-    async def voice_synthesize_root(
-        request: dict,
-        current_user: dict = Depends(get_current_user)
-    ):
-        """Voice synthesis endpoint at root level for frontend compatibility"""
-        try:
-            if not any(role in current_user.get('roles', []) for role in ['doctor', 'admin']):
-                raise HTTPException(status_code=403, detail="Only doctors and admins can use voice features")
-            
-            logger.info(f"Voice synthesis initiated by {current_user['email']}")
-            
-            # Extract parameters from request
-            text = request.get('text', '')
-            language = request.get('language', 'en-US')
-            return_format = request.get('return_format', 'mp3')
-            
-            if not text:
-                raise HTTPException(status_code=400, detail="Text is required")
-            
-            # Import voice function
-            try:
-                from voice import text_to_speech
-            except ImportError:
-                # Fallback if voice module is not available
-                raise HTTPException(status_code=500, detail="Voice synthesis not available")
-            
-            # Convert language code for gTTS (e.g., 'en-US' -> 'en')
-            language_code = language.split('-')[0] if '-' in language else language
-            
-            # Generate speech
-            audio_data = text_to_speech(text, language=language_code)
-            
-            # Return audio data
-            return StreamingResponse(
-                io.BytesIO(audio_data),
-                media_type=f"audio/{return_format}",
-                headers={"Content-Disposition": f"attachment; filename=speech.{return_format}"}
-            )
-            
-        except HTTPException:
-            raise
-        except Exception as e:
-            logger.error(f"Error in voice synthesis: {e}")
-            raise HTTPException(status_code=500, detail="Error generating voice output")
+    # @router.post("/voice/synthesize")
+    # async def voice_synthesize_root(
+    #     request: dict,
+    #     current_user: dict = Depends(get_current_user)
+    # ):
+    #     """Voice synthesis endpoint at root level for frontend compatibility"""
+    #     try:
+    #         if not any(role in current_user.get('roles', []) for role in ['doctor', 'admin']):
+    #             raise HTTPException(status_code=403, detail="Only doctors and admins can use voice features")
+    #         
+    #         logger.info(f"Voice synthesis initiated by {current_user['email']}")
+    #         
+    #         # Extract parameters from request
+    #         text = request.get('text', '')
+    #         language = request.get('language', 'en-US')
+    #         return_format = request.get('return_format', 'mp3')
+    #         
+    #         if not text:
+    #             raise HTTPException(status_code=400, detail="Text is required")
+    #         
+    #         # Import voice function
+    #         try:
+    #             from voice import text_to_speech
+    #         except ImportError:
+    #             # Fallback if voice module is not available
+    #             raise HTTPException(status_code=500, detail="Voice synthesis not available")
+    #         
+    #         # Convert language code for gTTS (e.g., 'en-US' -> 'en')
+    #         language_code = language.split('-')[0] if '-' in language else language
+    #         
+    #         # Generate speech
+    #         audio_data = text_to_speech(text, language=language_code)
+    #         
+    #         # Return audio data
+    #         return StreamingResponse(
+    #             io.BytesIO(audio_data),
+    #             media_type=f"audio/{return_format}",
+    #             headers={"Content-Disposition": f"attachment; filename=speech.{return_format}"}
+    #         )
+    #         
+    #     except HTTPException:
+    #         raise
+    #     except Exception as e:
+    #         logger.error(f"Error in voice synthesis: {e}")
+    #         raise HTTPException(status_code=500, detail="Error generating voice output")
     
-    # Add analyze-report endpoint at the root level for frontend compatibility
-    @router.post("/analyze-report")
-    async def analyze_report_root(
-        file: UploadFile = File(...),
-        current_user: dict = Depends(get_current_user)
-    ):
-        """Analyze uploaded report (PDF, DOCX, etc.) at root level"""
-        try:
-            if not any(role in current_user.get('roles', []) for role in ['doctor', 'admin']):
-                raise HTTPException(status_code=403, detail="Only doctors and admins can analyze reports")
-            
-            logger.info(f"Report analysis initiated by {current_user['email']}")
-            
-            # Read file content
-            file_content = await file.read()
-            file_extension = file.filename.split('.')[-1].lower()
-            
-            # Extract text based on file type
-            if file_extension == 'pdf':
-                try:
-                    from voice import extract_text_from_pdf
-                    text_content = extract_text_from_pdf(file_content)
-                except Exception as e:
-                    logger.error(f"PDF text extraction failed: {e}")
-                    text_content = "Failed to extract text from PDF"
-            elif file_extension in ['docx', 'doc']:
-                try:
-                    from docx import Document
-                    if Document:
-                        doc = Document(io.BytesIO(file_content))
-                        text_content = '\n'.join([paragraph.text for paragraph in doc.paragraphs])
-                    else:
-                        text_content = "Document processing not available"
-                except Exception as e:
-                    logger.error(f"DOCX text extraction failed: {e}")
-                    text_content = "Failed to extract text from document"
-            else:
-                text_content = "Unsupported file format"
-            
-            # Analyze the content (for now, return a simple analysis)
-            analysis_result = {
-                "file_name": file.filename,
-                "file_type": file_extension,
-                "extracted_text": text_content[:500] + "..." if len(text_content) > 500 else text_content,
-                "analysis": {
-                    "summary": f"Analyzed {file.filename} containing {len(text_content)} characters",
-                    "key_findings": ["Sample finding 1", "Sample finding 2"],
-                    "recommendations": ["Sample recommendation 1", "Sample recommendation 2"]
-                },
-                "timestamp": datetime.utcnow().isoformat()
-            }
-            
-            return analysis_result
-            
-        except Exception as e:
-            logger.error(f"Error analyzing report: {e}")
-            raise HTTPException(status_code=500, detail="Error analyzing report")
+    # @router.post("/analyze-report")
+    # async def analyze_report_root(
+    #     file: UploadFile = File(...),
+    #     current_user: dict = Depends(get_current_user)
+    # ):
+    #     """Analyze uploaded report (PDF, DOCX, etc.) at root level"""
+    #     try:
+    #         if not any(role in current_user.get('roles', []) for role in ['doctor', 'admin']):
+    #             raise HTTPException(status_code=403, detail="Only doctors and admins can analyze reports")
+    #         
+    #         logger.info(f"Report analysis initiated by {current_user['email']}")
+    #         
+    #         # Read file content
+    #         file_content = await file.read()
+    #         file_extension = file.filename.split('.')[-1].lower()
+    #         
+    #         # Extract text based on file type
+    #         if file_extension == 'pdf':
+    #             try:
+    #                 from voice import extract_text_from_pdf
+    #                 text_content = extract_text_from_pdf(file_content)
+    #                 except Exception as e:
+    #                     logger.error(f"PDF text extraction failed: {e}")
+    #                     text_content = "Failed to extract text from PDF"
+    #             elif file_extension in ['docx', 'doc']:
+    #                 try:
+    #                     from docx import Document
+    #                     if Document:
+    #                         doc = Document(io.BytesIO(file_content))
+    #                         text_content = '\n'.join([paragraph.text for paragraph in doc.paragraphs])
+    #                     else:
+    #                         text_content = "Document processing not available"
+    #                 except Exception as e:
+    #                     logger.error(f"DOCX text extraction failed: {e}")
+    #                     text_content = "Failed to extract text from document"
+    #             else:
+    #                 text_content = "Unsupported file format"
+    #             
+    #             # Analyze the content (for now, return a simple analysis)
+    #             analysis_result = {
+    #                 "file_name": file.filename,
+    #                 "file_type": file_extension,
+    #                 "extracted_text": text_content[:500] + "..." if len(text_content) > 500 else text_content,
+    #                 "analysis": {
+    #                 "summary": f"Analyzed {file.filename} containing {len(text_content)} characters",
+    #                 "key_findings": ["Sample finding 1", "Sample finding 2"],
+    #                 "recommendations": ["Sample recommendation 1", "Sample recommendation 2"]
+    #             },
+    #                 "timestamp": datetime.utcnow().isoformat()
+    #             }
+    #             
+    #             return analysis_result
+    #             
+    #         except Exception as e:
+    #             logger.error(f"Error analyzing report: {e}")
+    #             raise HTTPException(status_code=500, detail="Error analyzing report")
     
     return router
 

api/routes/txagent.py

@@ -236,7 +236,17 @@ async def get_patient_analysis_results(
                     "factors": risk_factors
                 },
                 "summary": analysis.get("summary", ""),
-                "recommendations": analysis.get("recommendations", [])
+                "recommendations": analysis.get("recommendations", []),
+                # Add patient demographic information for modal display
+                "date_of_birth": patient.get("date_of_birth"),
+                "gender": patient.get("gender"),
+                "city": patient.get("city"),
+                "state": patient.get("state"),
+                "address": patient.get("address"),
+                "postal_code": patient.get("postal_code"),
+                "country": patient.get("country"),
+                "marital_status": patient.get("marital_status"),
+                "language": patient.get("language")
             }
             enriched_results.append(formatted_analysis)
 

models/entities.py

@@ -3,36 +3,78 @@ from typing import List, Optional
 from datetime import datetime
 
 class Condition(BaseModel):
-    id: str
+    id: Optional[str] = None
     code: str
     status: Optional[str] = ""
     onset_date: Optional[str] = None
     recorded_date: Optional[str] = None
     verification_status: Optional[str] = ""
+    category: Optional[str] = ""
 
 class Medication(BaseModel):
-    id: str
+    id: Optional[str] = None
     name: str
     status: str
     prescribed_date: Optional[str] = None
     requester: Optional[str] = ""
     dosage: Optional[str] = ""
+    intent: Optional[str] = ""
+    priority: Optional[str] = ""
 
 class Encounter(BaseModel):
-    id: str
+    id: Optional[str] = None
     type: str
     status: str
-    period: dict
+    period: Optional[dict] = None
     service_provider: Optional[str] = ""
+    class_type: Optional[str] = ""
+    reason: Optional[str] = ""
+
+class Observation(BaseModel):
+    id: Optional[str] = None
+    code: str
+    value: Optional[str] = ""
+    unit: Optional[str] = ""
+    status: Optional[str] = ""
+    effective_date: Optional[str] = None
+    category: Optional[str] = ""
+
+class Procedure(BaseModel):
+    id: Optional[str] = None
+    code: str
+    status: str
+    performed_date: Optional[str] = None
+    performer: Optional[str] = ""
+    reason: Optional[str] = ""
+
+class Immunization(BaseModel):
+    id: Optional[str] = None
+    vaccine: str
+    status: str
+    date: Optional[str] = None
+    lot_number: Optional[str] = ""
+    expiration_date: Optional[str] = ""
+    manufacturer: Optional[str] = ""
+
+class Allergy(BaseModel):
+    id: Optional[str] = None
+    substance: str
+    status: Optional[str] = ""
+    severity: Optional[str] = ""
+    onset_date: Optional[str] = None
+    reaction: Optional[str] = ""
 
 class Note(BaseModel):
-    date: str
-    type: str
-    text: str
-    context: Optional[str] = ""
+    id: Optional[str] = None
+    title: Optional[str] = ""
+    date: Optional[str] = None
     author: Optional[str] = "System"
+    content: str
+    type: Optional[str] = ""
+    context: Optional[str] = ""
 
 class PatientCreate(BaseModel):
+    fhir_id: Optional[str] = None
     full_name: str
     gender: str
     date_of_birth: str
@@ -43,7 +85,14 @@ class PatientCreate(BaseModel):
     country: Optional[str] = "US"
     marital_status: Optional[str] = "Never Married"
     language: Optional[str] = "en"
+    source: Optional[str] = "appointment_booking"
+    import_date: Optional[str] = None
+    last_updated: Optional[str] = None
     conditions: Optional[List[Condition]] = []
     medications: Optional[List[Medication]] = []
     encounters: Optional[List[Encounter]] = []
+    observations: Optional[List[Observation]] = []
+    procedures: Optional[List[Procedure]] = []
+    immunizations: Optional[List[Immunization]] = []
+    allergies: Optional[List[Allergy]] = []
     notes: Optional[List[Note]] = []

routes/patients.py

@@ -52,7 +52,7 @@ class ConditionUpdate(BaseModel):
     onset_date: Optional[str] = None
     recorded_date: Optional[str] = None
     verification_status: Optional[str] = None
-    notes: Optional[str] = None
+    category: Optional[str] = None
 
 class MedicationUpdate(BaseModel):
     id: Optional[str] = None
@@ -61,6 +61,8 @@ class MedicationUpdate(BaseModel):
     prescribed_date: Optional[str] = None
     requester: Optional[str] = None
     dosage: Optional[str] = None
+    intent: Optional[str] = None
+    priority: Optional[str] = None
 
 class EncounterUpdate(BaseModel):
     id: Optional[str] = None
@@ -68,6 +70,42 @@ class EncounterUpdate(BaseModel):
     status: Optional[str] = None
     period: Optional[Dict[str, str]] = None
     service_provider: Optional[str] = None
+    class_type: Optional[str] = None
+    reason: Optional[str] = None
+
+class ObservationUpdate(BaseModel):
+    id: Optional[str] = None
+    code: Optional[str] = None
+    value: Optional[str] = None
+    unit: Optional[str] = None
+    status: Optional[str] = None
+    effective_date: Optional[str] = None
+    category: Optional[str] = None
+
+class ProcedureUpdate(BaseModel):
+    id: Optional[str] = None
+    code: Optional[str] = None
+    status: Optional[str] = None
+    performed_date: Optional[str] = None
+    performer: Optional[str] = None
+    reason: Optional[str] = None
+
+class ImmunizationUpdate(BaseModel):
+    id: Optional[str] = None
+    vaccine: Optional[str] = None
+    status: Optional[str] = None
+    date: Optional[str] = None
+    lot_number: Optional[str] = None
+    expiration_date: Optional[str] = None
+    manufacturer: Optional[str] = None
+
+class AllergyUpdate(BaseModel):
+    id: Optional[str] = None
+    substance: Optional[str] = None
+    status: Optional[str] = None
+    severity: Optional[str] = None
+    onset_date: Optional[str] = None
+    reaction: Optional[str] = None
 
 class NoteUpdate(BaseModel):
     id: Optional[str] = None
@@ -75,6 +113,8 @@ class NoteUpdate(BaseModel):
     date: Optional[str] = None
     author: Optional[str] = None
     content: Optional[str] = None
+    type: Optional[str] = None
+    context: Optional[str] = None
 
 class PatientUpdate(BaseModel):
     full_name: Optional[str] = None
@@ -90,6 +130,10 @@ class PatientUpdate(BaseModel):
     conditions: Optional[List[ConditionUpdate]] = None
     medications: Optional[List[MedicationUpdate]] = None
     encounters: Optional[List[EncounterUpdate]] = None
+    observations: Optional[List[ObservationUpdate]] = None
+    procedures: Optional[List[ProcedureUpdate]] = None
+    immunizations: Optional[List[ImmunizationUpdate]] = None
+    allergies: Optional[List[AllergyUpdate]] = None
     notes: Optional[List[NoteUpdate]] = None
 
 @router.get("/debug/count")
@@ -132,18 +176,25 @@ async def create_patient(
         patient_doc = patient_data.dict()
         now = datetime.utcnow().isoformat()
         
-        # Add system-generated fields
-        patient_doc.update({
-            "fhir_id": str(uuid.uuid4()),
-            "import_date": now,
-            "last_updated": now,
-            "source": "manual",
-            "created_by": current_user.get('email')
-        })
-        
-        # Ensure arrays exist even if empty
-        for field in ['conditions', 'medications', 'encounters', 'notes']:
-            if field not in patient_doc:
+        # Add system-generated fields if not provided
+        if not patient_doc.get('fhir_id'):
+            patient_doc['fhir_id'] = str(uuid.uuid4())
+        if not patient_doc.get('import_date'):
+            patient_doc['import_date'] = now
+        if not patient_doc.get('last_updated'):
+            patient_doc['last_updated'] = now
+        if not patient_doc.get('source'):
+            patient_doc['source'] = 'appointment_booking'
+        
+        patient_doc['created_by'] = current_user.get('email')
+        
+        # Ensure all array fields exist even if empty
+        array_fields = [
+            'conditions', 'medications', 'encounters', 'observations', 
+            'procedures', 'immunizations', 'allergies', 'notes'
+        ]
+        for field in array_fields:
+            if field not in patient_doc or patient_doc[field] is None:
                 patient_doc[field] = []
         
         # Insert the patient document
@@ -888,11 +939,15 @@ async def update_patient(
             if value is not None:
                 update_ops["$set"][key] = value
         
-        # Handle array updates (conditions, medications, encounters, notes)
+        # Handle array updates (all array fields)
         array_fields = {
             "conditions": update_data.conditions,
             "medications": update_data.medications,
             "encounters": update_data.encounters,
+            "observations": update_data.observations,
+            "procedures": update_data.procedures,
+            "immunizations": update_data.immunizations,
+            "allergies": update_data.allergies,
             "notes": update_data.notes
         }
         
@@ -927,6 +982,26 @@ async def update_patient(
                             status_code=status.HTTP_400_BAD_REQUEST,
                             detail=f"Encounter type is required for {field}"
                         )
+                    if field == "observations" and not item_dict.get("code"):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"Observation code is required for {field}"
+                        )
+                    if field == "procedures" and not item_dict.get("code"):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"Procedure code is required for {field}"
+                        )
+                    if field == "immunizations" and not item_dict.get("vaccine"):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"Immunization vaccine is required for {field}"
+                        )
+                    if field == "allergies" and not item_dict.get("substance"):
+                        raise HTTPException(
+                            status_code=status.HTTP_400_BAD_REQUEST,
+                            detail=f"Allergy substance is required for {field}"
+                        )
                     if field == "notes" and not item_dict.get("content"):
                         raise HTTPException(
                             status_code=status.HTTP_400_BAD_REQUEST,
@@ -973,6 +1048,10 @@ async def update_patient(
             "conditions": updated_patient.get("conditions", []),
             "medications": updated_patient.get("medications", []),
             "encounters": updated_patient.get("encounters", []),
+            "observations": updated_patient.get("observations", []),
+            "procedures": updated_patient.get("procedures", []),
+            "immunizations": updated_patient.get("immunizations", []),
+            "allergies": updated_patient.get("allergies", []),
             "notes": updated_patient.get("notes", []),
             "source": updated_patient.get("source"),
             "import_date": updated_patient.get("import_date"),

utils.py

@@ -63,7 +63,16 @@ def serialize_patient(patient: dict) -> dict:
 
 def compute_patient_data_hash(data: dict) -> str:
     """Compute hash of patient data for change detection"""
-    serialized = json.dumps(data, sort_keys=True)
+    # Custom JSON encoder to handle datetime objects
+    class DateTimeEncoder(json.JSONEncoder):
+        def default(self, obj):
+            if isinstance(obj, datetime):
+                return obj.isoformat()
+            elif isinstance(obj, ObjectId):
+                return str(obj)
+            return super().default(obj)
+    
+    serialized = json.dumps(data, sort_keys=True, cls=DateTimeEncoder)
     return hashlib.sha256(serialized.encode()).hexdigest()
 
 def compute_file_content_hash(file_content: bytes) -> str: