Updating patient routes

src/api/routes/patient.py

@@ -1,97 +1,107 @@
-# api/routes/patient.py
+# src/api/routes/patient.py
 
-from bson import ObjectId
-from bson.errors import InvalidId
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, status
 
-from src.data.repositories.patient import (create_patient, get_patient_by_id,
-                                           search_patients,
-                                           update_patient_profile)
-from src.data.repositories.session import list_patient_sessions
-from src.models.user import PatientCreateRequest, PatientUpdateRequest
+from src.core.state import AppState, get_state
+from src.models.patient import (Patient, PatientCreateRequest,
+                                PatientUpdateRequest)
+from src.models.session import Session
 from src.utils.logger import logger
 
 router = APIRouter(prefix="/patient", tags=["Patient"])
 
-@router.post("")
-async def create_patient_profile(req: PatientCreateRequest):
-	try:
-		logger().info(f"POST /patient name={req.name}")
-		patient_id = create_patient(
-			req.name,
-			req.age,
-			req.sex,
-			req.ethnicity,
-			req.address,
-			req.phone,
-			req.email,
-			req.medications,
-			req.past_assessment_summary,
-			req.assigned_doctor_id
-		)
-		#patient_id["_id"] = str(patient_id.get("_id")) if patient_id.get("_id") else None
-		logger().info(f"Created patient {req.name} id={patient_id}")
-		return { "patient_id": patient_id }
-	except Exception as e:
-		logger().error(f"Error creating patient: {e}")
-		raise HTTPException(status_code=500, detail=str(e))
-
-@router.get("/search")
-async def search_patients_route(q: str, limit: int = 20):
-	try:
-		logger().info(f"GET /patient/search q='{q}' limit={limit}")
-		results = search_patients(q, limit=limit)
-		logger().info(f"Search returned {len(results)} results")
-		return {"results": results}
-	except Exception as e:
-		logger().error(f"Error searching patients: {e}")
-		raise HTTPException(status_code=500, detail=str(e))
-
-@router.get("/{patient_id}")
-async def get_patient(patient_id: str):
-	try:
-		logger().info(f"GET /patient/{patient_id}")
-		try:
-			patient = get_patient_by_id(patient_id)
-		except InvalidId:
-			raise HTTPException(status_code=400, detail="Invalid patient ID format")
-
-		if not patient:
-			raise HTTPException(status_code=404, detail="Patient not found")
-
-		return patient
-	except HTTPException:
-		raise
-	except Exception as e:
-		logger().error(f"Error getting patient: {e}")
-		raise HTTPException(status_code=500, detail=str(e))
-
-@router.patch("/{patient_id}")
-async def update_patient(patient_id: str, req: PatientUpdateRequest):
-	try:
-		# Validate ObjectId format
-		if not ObjectId.is_valid(patient_id):
-			raise HTTPException(status_code=400, detail="Invalid patient ID format")
-
-		payload = {k: v for k, v in req.model_dump().items() if v is not None}
-		logger().info(f"PATCH /patient/{patient_id} fields={list(payload.keys())}")
-		modified = update_patient_profile(patient_id, payload)
-		if modified == 0:
-			return {"message": "No changes"}
-		return {"message": "Updated"}
-	except HTTPException:
-		raise
-	except Exception as e:
-		logger().error(f"Error updating patient: {e}")
-		raise HTTPException(status_code=500, detail=str(e))
-
-@router.get("/{patient_id}/session")
-async def list_sessions_for_patient(patient_id: str):
-	"""List sessions for a patient from Mongo"""
-	try:
-		logger().info(f"GET /patient/{patient_id}/session")
-		sessions = list_patient_sessions(patient_id)
-		return {"sessions": sessions}
-	except Exception as e:
-		logger().error(f"Error listing sessions: {e}")
-		raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("", response_model=list[Patient])
+async def search_or_get_all_patients(
+	q: str | None = None,
+	limit: int = 20,
+	state: AppState = Depends(get_state)
+):
+	"""
+	Searches for patients by name if a query 'q' is provided.
+	Otherwise, this endpoint would list all patients (functionality not yet in repo).
+	"""
+	logger().info(f"GET /patient?q='{q}' limit={limit}")
+	if not q:
+		# In the future, you could add a get_all_patients method here.
+		raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="A search query 'q' is required.")
+
+	patients = state.memory_manager.search_patients(q, limit=limit)
+	logger().info(f"Search returned {len(patients)} results")
+	return patients
+
+
+@router.post("", response_model=Patient, status_code=status.HTTP_201_CREATED)
+async def create_patient_profile(
+	req: PatientCreateRequest,
+	state: AppState = Depends(get_state)
+):
+	"""Creates a new patient profile."""
+	logger().info(f"POST /patient name={req.name}")
+	patient_id = state.memory_manager.create_patient(**req.model_dump())
+
+	if not patient_id:
+		raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Patient could not be created due to invalid data.")
+
+	new_patient = state.memory_manager.get_patient_by_id(patient_id)
+	if not new_patient:
+		raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Could not find newly created patient.")
+
+	logger().info(f"Created patient {req.name} id={patient_id}")
+	return new_patient
+
+
+@router.get("/{patient_id}", response_model=Patient)
+async def get_patient_by_id(
+	patient_id: str,
+	state: AppState = Depends(get_state)
+):
+	"""Retrieves a single patient by their unique ID."""
+	logger().info(f"GET /patient/{patient_id}")
+	patient = state.memory_manager.get_patient_by_id(patient_id)
+	if not patient:
+		raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Patient not found")
+	return patient
+
+
+@router.patch("/{patient_id}", response_model=Patient)
+async def update_patient(
+	patient_id: str,
+	req: PatientUpdateRequest,
+	state: AppState = Depends(get_state)
+):
+	"""Updates a patient's profile with the provided fields."""
+	# Get only the fields that the client actually sent
+	updates = req.model_dump(exclude_unset=True)
+	if not updates:
+		raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No update fields provided.")
+
+	logger().info(f"PATCH /patient/{patient_id} fields={list(updates.keys())}")
+	modified_count = state.memory_manager.update_patient_profile(patient_id, updates)
+
+	if modified_count == 0:
+		# Check if the patient exists to differentiate between "not found" and "no changes made"
+		if not state.memory_manager.get_patient_by_id(patient_id):
+			raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Patient not found")
+
+	# Return the full, updated patient object
+	updated_patient = state.memory_manager.get_patient_by_id(patient_id)
+	if not updated_patient:
+		raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Could not find patient after update.")
+
+	return updated_patient
+
+
+@router.get("/{patient_id}/session", response_model=list[Session])
+async def list_sessions_for_patient(
+	patient_id: str,
+	state: AppState = Depends(get_state)
+):
+	"""Lists all chat sessions associated with a specific patient."""
+	logger().info(f"GET /patient/{patient_id}/session")
+	# First, verify the patient exists
+	if not state.memory_manager.get_patient_by_id(patient_id):
+		raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Patient not found")
+
+	sessions = state.memory_manager.list_patient_sessions(patient_id)
+	return sessions

src/core/memory_manager.py

@@ -3,8 +3,10 @@
 from src.data.connection import ActionFailed
 from src.data.repositories import account as account_repo
 from src.data.repositories import medical_memory as memory_repo
+from src.data.repositories import patient as patient_repo
 from src.data.repositories import session as session_repo
 from src.models.account import Account
+from src.models.patient import Patient
 from src.models.session import Session
 from src.services import summariser
 from src.services.nvidia import nvidia_chat
@@ -60,6 +62,39 @@ class MemoryManager:
 		except ActionFailed as e:
 			logger().error(f"Failed to search accounts in MemoryManager: {e}")
 			return []
+	# --- Patient Management Facade ---
+
+	def create_patient(self, **kwargs) -> str | None:
+		"""Creates a new patient record."""
+		try:
+			return patient_repo.create_patient(**kwargs)
+		except ActionFailed as e:
+			logger().error(f"Failed to create patient in MemoryManager: {e}")
+			return None
+
+	def get_patient_by_id(self, patient_id: str) -> Patient | None:
+		"""Retrieves a patient by their unique ID."""
+		try:
+			return patient_repo.get_patient_by_id(patient_id)
+		except ActionFailed as e:
+			logger().error(f"Failed to get patient '{patient_id}' in MemoryManager: {e}")
+			return None
+
+	def update_patient_profile(self, patient_id: str, updates: dict) -> int:
+		"""Updates a patient's profile."""
+		try:
+			return patient_repo.update_patient_profile(patient_id, updates)
+		except ActionFailed as e:
+			logger().error(f"Failed to update patient '{patient_id}' in MemoryManager: {e}")
+			return 0
+
+	def search_patients(self, query: str, limit: int = 10) -> list[Patient]:
+		"""Searches for patients by name."""
+		try:
+			return patient_repo.search_patients(query, limit=limit)
+		except ActionFailed as e:
+			logger().error(f"Failed to search patients in MemoryManager: {e}")
+			return []
 
 	# --- Session Management Facade ---
 
@@ -95,6 +130,14 @@ class MemoryManager:
 			logger().error(f"Failed to update title for session '{session_id}': {e}")
 			return False
 
+	def list_patient_sessions(self, patient_id: str) -> list[Session]:
+		"""Retrieves all sessions for a specific patient."""
+		try:
+			return session_repo.list_patient_sessions(patient_id, limit=self.max_sessions_per_user)
+		except ActionFailed as e:
+			logger().error(f"Failed to get sessions for patient '{patient_id}': {e}")
+			return []
+
 	# --- Core Business Logic ---
 
 	async def process_medical_exchange(

src/models/patient.py

@@ -2,6 +2,8 @@
 
 from datetime import datetime
 
+from pydantic import BaseModel
+
 from src.models.common import BaseMongoModel, PyObjectId
 
 
@@ -19,3 +21,27 @@ class Patient(BaseMongoModel):
 	medications: list[str] | None = None
 	past_assessment_summary: str | None = None
 	assigned_doctor_id: PyObjectId | None = None
+
+class PatientCreateRequest(BaseModel):
+	name: str
+	age: int
+	sex: str
+	ethnicity: str
+	address: str | None = None
+	phone: str | None = None
+	email: str | None = None
+	medications: list[str] | None = None
+	past_assessment_summary: str | None = None
+	assigned_doctor_id: str | None = None
+
+class PatientUpdateRequest(BaseModel):
+	name: str | None = None
+	age: int | None = None
+	sex: str | None = None
+	ethnicity: str | None = None
+	address: str | None = None
+	phone: str | None = None
+	email: str | None = None
+	medications: list[str] | None = None
+	past_assessment_summary: str | None = None
+	assigned_doctor_id: str | None = None

src/models/user.py

@@ -1,28 +0,0 @@
-# src/model/user.py
-
-from pydantic import BaseModel
-
-
-class PatientCreateRequest(BaseModel):
-	name: str
-	age: int
-	sex: str
-	ethnicity: str
-	address: str | None = None
-	phone: str | None = None
-	email: str | None = None
-	medications: list[str] | None = None
-	past_assessment_summary: str | None = None
-	assigned_doctor_id: str | None = None
-
-class PatientUpdateRequest(BaseModel):
-	name: str | None = None
-	age: int | None = None
-	sex: str | None = None
-	ethnicity: str | None = None
-	address: str | None = None
-	phone: str | None = None
-	email: str | None = None
-	medications: list[str] | None = None
-	past_assessment_summary: str | None = None
-	assigned_doctor_id: str | None = None