Solve updatePatientDisplay func with undefined handler

src/data/repositories/account.py

@@ -1,220 +0,0 @@
-# src/data/repositories/account.py
-"""
-User account management operations for MongoDB.
-Each account represents a doctor.
-
-## Fields
-	_id: index
-	name: The name attached to the account
-	role: What type of account this is
-	specialty: Any extra information about the account
-	created_at: The timestamp when the account was created
-	updated_at: The timestamp when the account data was last modified
-	last_seen: The last time this account was retrieved
-"""
-
-import re
-from datetime import datetime, timezone
-from typing import Any
-
-from bson import ObjectId
-from bson.errors import InvalidId
-from pandas import DataFrame
-from pymongo import ASCENDING
-from pymongo.errors import ConnectionFailure, PyMongoError, WriteError
-
-from src.data.connection import (ActionFailed, Collections, get_collection,
-                                 setup_collection)
-from src.models.account import Account
-from src.utils.logger import logger
-
-VALID_ROLES = [
-	"Doctor",
-	"Healthcare Prof",
-	"Nurse",
-	"Caregiver",
-	"Physician",
-	"Medical Student",
-	"Other"
-]
-
-def init(
-	*,
-	collection_name: str = Collections.ACCOUNT,
-	validator_path: str = "schemas/account_validator.json",
-	drop: bool = False
-):
-	"""Initializes the collection, applying schema validation."""
-	try:
-		if drop:
-			get_collection(collection_name).drop()
-		setup_collection(collection_name, validator_path)
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Failed to initialize collection '{collection_name}': {e}")
-		raise ActionFailed(f"Database operation failed during initialization: {e}") from e
-
-def get_account_frame(
-	*,
-	collection_name: str = Collections.ACCOUNT
-) -> DataFrame:
-	"""Get accounts as a pandas DataFrame, raising ActionFailed on error."""
-	try:
-		collection = get_collection(collection_name)
-		return DataFrame(collection.find())
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Failed to retrieve account frame: {e}")
-		raise ActionFailed(f"Could not retrieve accounts for DataFrame: {e}") from e
-
-def create_account(
-	name: str,
-	role: str,
-	specialty: str | None = None,
-	*,
-	collection_name: str = Collections.ACCOUNT
-) -> str:
-	"""Creates a new user account, raising ActionFailed on error."""
-	now = datetime.now(timezone.utc)
-	user_data: dict[str, Any] = {
-		"name": name,
-		"role" : role,
-		"created_at": now,
-		"updated_at": now,
-		"last_seen": now
-	}
-	if specialty:
-		user_data["specialty"] = specialty
-
-	try:
-		collection = get_collection(collection_name)
-		result = collection.insert_one(user_data)
-		logger().info(f"Created new account: {result.inserted_id}")
-		return str(result.inserted_id)
-	except WriteError as e:
-		logger().error(f"Failed to create account due to data conflict: {e}")
-		raise ActionFailed(f"Account could not be created. Data is conflicting or invalid.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error while creating account: {e}")
-		raise ActionFailed(f"A database error occurred while creating the account.") from e
-
-def update_account(
-	user_id: str,
-	updates: dict[str, Any],
-	*,
-	collection_name: str = Collections.ACCOUNT
-) -> bool:
-	"""Updates an existing user account, raising ActionFailed on error."""
-	try:
-		obj_user_id = ObjectId(user_id)
-		collection = get_collection(collection_name)
-
-		if "created_at" in updates:
-			logger().warning("Attempting to modify the 'created_at' attribute of an account. This is not allowed.")
-			updates.pop("created_at")
-		updates["updated_at"] = datetime.now(timezone.utc)
-
-		result = collection.update_one(
-			{"_id": obj_user_id},
-			{"$set": updates}
-		)
-		return result.modified_count > 0
-	except InvalidId as e:
-		logger().error(f"Invalid user_id format for update: '{user_id}'")
-		raise ActionFailed(f"The provided user ID '{user_id}' is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error while updating account '{user_id}': {e}")
-		raise ActionFailed(f"A database error occurred while updating the account.") from e
-
-def get_account(
-	user_id: str,
-	*,
-	collection_name: str = Collections.ACCOUNT
-) -> Account | None:
-	"""Retrieves an account by ID. Returns a Pydantic Account object or None."""
-	try:
-		obj_user_id = ObjectId(user_id)
-		collection = get_collection(collection_name)
-		now = datetime.now(timezone.utc)
-
-		account_dict = collection.find_one_and_update(
-			{"_id": obj_user_id},
-			{"$set": {"last_seen": now}},
-			return_document=True
-		)
-
-		if account_dict:
-			return Account.model_validate(account_dict)
-		return None
-	except InvalidId as e:
-		logger().error(f"Invalid user_id format for get: '{user_id}'")
-		raise ActionFailed(f"The provided user ID '{user_id}' is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error while getting account '{user_id}': {e}")
-		raise ActionFailed(f"A database error occurred while retrieving the account.") from e
-
-def get_account_by_name(
-	name: str,
-	*,
-	collection_name: str = Collections.ACCOUNT
-) -> Account | None:
-	"""
-	Gets an account by name. Returns a Pydantic Account object or None.
-	@deprecated Use search_accounts instead for more flexibility.
-	"""
-	logger().info(f"Trying to retrieve account: {name}")
-	try:
-		collection = get_collection(collection_name)
-		now = datetime.now(timezone.utc)
-		account_dict = collection.find_one_and_update(
-			{"name": name},
-			{"$set": {"last_seen": now}},
-			return_document=True
-		)
-		if account_dict:
-			return Account.model_validate(account_dict)
-		return None
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error while getting account by name '{name}': {e}")
-		raise ActionFailed(f"A database error occurred while retrieving the account by name.") from e
-
-def search_accounts(
-	query: str,
-	limit: int = 10,
-	*,
-	collection_name: str = Collections.ACCOUNT
-) -> list[Account]:
-	"""Searches accounts by name, returning a list of Pydantic Account objects."""
-	if not query:
-		return []
-
-	logger().info(f"Searching accounts with query: '{query}', limit: {limit}")
-	pattern = re.compile(re.escape(query), re.IGNORECASE)
-
-	try:
-		collection = get_collection(collection_name)
-		cursor = collection.find({
-			"name": {"$regex": pattern}
-		}).sort("name", ASCENDING).limit(limit)
-
-		accounts = [Account.model_validate(doc) for doc in cursor]
-		logger().info(f"Found {len(accounts)} accounts matching query")
-		return accounts
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error during account search for query '{query}': {e}")
-		raise ActionFailed(f"A database error occurred during the account search.") from e
-
-def get_all_accounts(
-	limit: int = 50,
-	*,
-	collection_name: str = Collections.ACCOUNT
-) -> list[Account]:
-	"""Gets all accounts, returning a list of Pydantic Account objects."""
-	try:
-		collection = get_collection(collection_name)
-		cursor = collection.find().sort("name", ASCENDING).limit(limit)
-
-		accounts = [Account.model_validate(doc) for doc in cursor]
-		logger().info(f"Retrieved {len(accounts)} accounts")
-		return accounts
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error while getting all accounts: {e}")
-		raise ActionFailed(f"A database error occurred while retrieving all accounts.") from e

src/data/repositories/emr.py

@@ -1,285 +0,0 @@
-# src/data/repositories/emr.py
-
-import json
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
-
-from bson import ObjectId
-from pymongo import ASCENDING, DESCENDING
-from pymongo.errors import ConnectionFailure, OperationFailure, PyMongoError
-
-from src.data.connection import ActionFailed, get_collection, setup_collection
-from src.models.emr import EMRCreateRequest, EMRResponse, ExtractedData
-from src.utils.logger import logger
-
-EMR_COLLECTION = "emr"
-
-
-def init():
-    """Create the EMR collection with validation schema."""
-    try:
-        setup_collection(EMR_COLLECTION, "schemas/emr_validator.json")
-        # Create indexes for better performance
-        collection = get_collection(EMR_COLLECTION)
-        collection.create_index("patient_id")
-        collection.create_index("doctor_id")
-        collection.create_index("session_id")
-        collection.create_index("message_id")
-        collection.create_index("created_at")
-        collection.create_index([("patient_id", ASCENDING), ("created_at", DESCENDING)])
-        collection.create_index([("patient_id", ASCENDING), ("doctor_id", ASCENDING)])
-        collection.create_index([("session_id", ASCENDING), ("created_at", DESCENDING)])
-        collection.create_index("confidence_score")
-        logger().info("EMR collection created successfully with indexes")
-    except Exception as e:
-        logger().error(f"Error creating EMR collection: {e}")
-        raise
-
-
-def create_emr_entry(emr_data: EMRCreateRequest, embeddings: List[float]) -> str:
-    """Create a new EMR entry in the database."""
-    try:
-        collection = get_collection(EMR_COLLECTION)
-
-        # Check if EMR entry already exists for this message
-        existing = collection.find_one({"message_id": emr_data.message_id})
-        if existing:
-            logger().warning(f"EMR entry already exists for message {emr_data.message_id}")
-            return str(existing["_id"])
-
-        now = datetime.now(timezone.utc)
-
-        doc = {
-            "patient_id": emr_data.patient_id,
-            "doctor_id": emr_data.doctor_id,
-            "message_id": emr_data.message_id,
-            "session_id": emr_data.session_id,
-            "original_message": emr_data.original_message,
-            "extracted_data": emr_data.extracted_data.model_dump(),
-            "embeddings": embeddings,
-            "confidence_score": emr_data.confidence_score,
-            "created_at": now,
-            "updated_at": now
-        }
-
-        result = collection.insert_one(doc)
-        logger().info(f"Created EMR entry for patient {emr_data.patient_id}, message {emr_data.message_id}")
-        return str(result.inserted_id)
-
-    except Exception as e:
-        logger().error(f"Error creating EMR entry: {e}")
-        raise
-
-
-def get_emr_by_id(emr_id: str) -> Optional[Dict[str, Any]]:
-    """Get an EMR entry by its ID."""
-    try:
-        collection = get_collection(EMR_COLLECTION)
-        result = collection.find_one({"_id": ObjectId(emr_id)})
-        if result:
-            result["_id"] = str(result["_id"])
-        return result
-    except Exception as e:
-        logger().error(f"Error getting EMR by ID {emr_id}: {e}")
-        return None
-
-
-def get_patient_emr_entries(
-    patient_id: str,
-    limit: int = 20,
-    offset: int = 0
-) -> List[Dict[str, Any]]:
-    """Get EMR entries for a specific patient, ordered by creation date."""
-    try:
-        collection = get_collection(EMR_COLLECTION)
-        cursor = collection.find(
-            {"patient_id": patient_id}
-        ).sort("created_at", DESCENDING).skip(offset).limit(limit)
-
-        results = []
-        for doc in cursor:
-            doc["_id"] = str(doc["_id"])
-            results.append(doc)
-
-        logger().info(f"Retrieved {len(results)} EMR entries for patient {patient_id}")
-        return results
-
-    except Exception as e:
-        logger().error(f"Error getting patient EMR entries: {e}")
-        return []
-
-
-def search_emr_by_semantic_similarity(
-    patient_id: str,
-    query_embeddings: List[float],
-    limit: int = 10,
-    threshold: float = 0.7
-) -> List[Dict[str, Any]]:
-    """Search EMR entries using semantic similarity with embeddings."""
-    try:
-        collection = get_collection(EMR_COLLECTION)
-
-        # Use MongoDB's vector search capabilities if available
-        # For now, we'll implement a simple cosine similarity search
-        pipeline = [
-            {"$match": {"patient_id": patient_id}},
-            {
-                "$addFields": {
-                    "similarity": {
-                        "$let": {
-                            "vars": {
-                                "dotProduct": {
-                                    "$reduce": {
-                                        "input": {"$range": [0, {"$size": "$embeddings"}]},
-                                        "initialValue": 0,
-                                        "in": {
-                                            "$add": [
-                                                "$$value",
-                                                {
-                                                    "$multiply": [
-                                                        {"$arrayElemAt": ["$embeddings", "$$this"]},
-                                                        {"$arrayElemAt": [query_embeddings, "$$this"]}
-                                                    ]
-                                                }
-                                            ]
-                                        }
-                                    }
-                                },
-                                "magnitudeA": {
-                                    "$sqrt": {
-                                        "$reduce": {
-                                            "input": "$embeddings",
-                                            "initialValue": 0,
-                                            "in": {"$add": ["$$value", {"$multiply": ["$$this", "$$this"]}]}
-                                        }
-                                    }
-                                },
-                                "magnitudeB": {
-                                    "$sqrt": {
-                                        "$reduce": {
-                                            "input": query_embeddings,
-                                            "initialValue": 0,
-                                            "in": {"$add": ["$$value", {"$multiply": ["$$this", "$$this"]}]}
-                                        }
-                                    }
-                                }
-                            },
-                            "in": {
-                                "$divide": [
-                                    "$$dotProduct",
-                                    {"$multiply": ["$$magnitudeA", "$$magnitudeB"]}
-                                ]
-                            }
-                        }
-                    }
-                }
-            },
-            {"$match": {"similarity": {"$gte": threshold}}},
-            {"$sort": {"similarity": DESCENDING}},
-            {"$limit": limit}
-        ]
-
-        results = list(collection.aggregate(pipeline))
-        for doc in results:
-            doc["_id"] = str(doc["_id"])
-
-        logger().info(f"Found {len(results)} similar EMR entries for patient {patient_id}")
-        return results
-
-    except Exception as e:
-        logger().error(f"Error searching EMR by similarity: {e}")
-        return []
-
-
-def update_emr_entry(emr_id: str, updates: Dict[str, Any]) -> bool:
-    """Update an EMR entry."""
-    try:
-        collection = get_collection(EMR_COLLECTION)
-        updates["updated_at"] = datetime.now(timezone.utc)
-
-        result = collection.update_one(
-            {"_id": ObjectId(emr_id)},
-            {"$set": updates}
-        )
-
-        success = result.modified_count > 0
-        if success:
-            logger().info(f"Updated EMR entry {emr_id}")
-        else:
-            logger().warning(f"No EMR entry found with ID {emr_id}")
-
-        return success
-
-    except Exception as e:
-        logger().error(f"Error updating EMR entry {emr_id}: {e}")
-        return False
-
-
-def delete_emr_entry(emr_id: str) -> bool:
-    """Delete an EMR entry."""
-    try:
-        collection = get_collection(EMR_COLLECTION)
-        result = collection.delete_one({"_id": ObjectId(emr_id)})
-
-        success = result.deleted_count > 0
-        if success:
-            logger().info(f"Deleted EMR entry {emr_id}")
-        else:
-            logger().warning(f"No EMR entry found with ID {emr_id}")
-
-        return success
-
-    except Exception as e:
-        logger().error(f"Error deleting EMR entry {emr_id}: {e}")
-        return False
-
-
-def check_emr_exists(message_id: str) -> bool:
-    """Check if an EMR entry already exists for a message."""
-    try:
-        collection = get_collection(EMR_COLLECTION)
-        existing = collection.find_one({"message_id": message_id})
-        return existing is not None
-    except Exception as e:
-        logger().error(f"Error checking EMR existence: {e}")
-        return False
-
-
-def get_emr_statistics(patient_id: str) -> Dict[str, Any]:
-    """Get EMR statistics for a patient."""
-    try:
-        collection = get_collection(EMR_COLLECTION)
-
-        pipeline = [
-            {"$match": {"patient_id": patient_id}},
-            {
-                "$group": {
-                    "_id": None,
-                    "total_entries": {"$sum": 1},
-                    "avg_confidence": {"$avg": "$confidence_score"},
-                    "latest_entry": {"$max": "$created_at"},
-                    "diagnosis_count": {
-                        "$sum": {"$size": "$extracted_data.diagnosis"}
-                    },
-                    "medication_count": {
-                        "$sum": {"$size": "$extracted_data.medications"}
-                    }
-                }
-            }
-        ]
-
-        result = list(collection.aggregate(pipeline))
-        if result:
-            return result[0]
-        else:
-            return {
-                "total_entries": 0,
-                "avg_confidence": 0,
-                "latest_entry": None,
-                "diagnosis_count": 0,
-                "medication_count": 0
-            }
-
-    except Exception as e:
-        logger().error(f"Error getting EMR statistics: {e}")
-        return {}

src/data/repositories/medical_memory.py

@@ -1,148 +0,0 @@
-# src/data/repositories/medical_memory.py
-"""
-Medical memory management operations for MongoDB.
-Medical memories are unstructured summaries, often with vector embeddings for semantic search.
-
-## Fields
-	_id: index
-	patient_id: The patient this memory relates to
-	doctor_id: The doctor involved in the context of this memory
-	session_id: The chat session this memory was derived from (optional)
-	summary: The unstructured text summary of the medical context
-	embedding: The vector embedding of the summary for semantic search (optional)
-	created_at: The timestamp when the memory was created
-"""
-from datetime import datetime, timezone
-
-import numpy as np
-from bson import ObjectId
-from bson.errors import InvalidId
-from pymongo import DESCENDING
-from pymongo.errors import ConnectionFailure, PyMongoError, WriteError
-
-from src.data.connection import (ActionFailed, Collections, get_collection,
-                                 setup_collection)
-from src.models.medical import MedicalMemory, SemanticSearchResult
-from src.utils.logger import logger
-
-
-def init(
-	*,
-	collection_name: str = Collections.MEDICAL_MEMORY,
-	validator_path: str = "schemas/medical_memory_validator.json",
-	drop: bool = False
-):
-	"""Initializes the medical_memory collection, applying schema validation."""
-	try:
-		if drop:
-			get_collection(collection_name).drop()
-		setup_collection(collection_name, validator_path)
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Failed to initialize collection '{collection_name}': {e}")
-		raise ActionFailed(f"Database operation failed during initialization: {e}") from e
-
-def create_memory(
-	patient_id: str,
-	doctor_id: str,
-	summary: str,
-	session_id: str | None = None,
-	embedding: list[float] | None = None,
-	*,
-	collection_name: str = Collections.MEDICAL_MEMORY
-) -> str:
-	"""Saves a new medical memory summary, raising ActionFailed on error."""
-	try:
-		collection = get_collection(collection_name)
-		doc = {
-			"patient_id": ObjectId(patient_id),
-			"doctor_id": ObjectId(doctor_id),
-			"summary": summary,
-			"created_at": datetime.now(timezone.utc)
-		}
-		if session_id:
-			doc["session_id"] = ObjectId(session_id)
-		if embedding:
-			doc["embedding"] = embedding
-
-		result = collection.insert_one(doc)
-		return str(result.inserted_id)
-	except InvalidId as e:
-		logger().error(f"Invalid ObjectId format provided for medical memory: {e}")
-		raise ActionFailed("Patient, Doctor, or Session ID is not a valid format.") from e
-	except (WriteError, ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Failed to create medical memory: {e}")
-		raise ActionFailed("A database error occurred while creating the medical memory.") from e
-
-def get_recent_memories(
-	patient_id: str,
-	limit: int = 20,
-	*,
-	collection_name: str = Collections.MEDICAL_MEMORY
-) -> list[MedicalMemory]:
-	"""Retrieves the most recent memory summaries for a patient."""
-	try:
-		obj_patient_id = ObjectId(patient_id)
-		collection = get_collection(collection_name)
-		cursor = collection.find(
-			{"patient_id": obj_patient_id}
-		).sort("created_at", DESCENDING).limit(limit)
-
-		return [MedicalMemory.model_validate(doc) for doc in cursor]
-	except InvalidId as e:
-		logger().error(f"Invalid patient_id format for get_recent_memories: '{patient_id}'")
-		raise ActionFailed("The provided patient ID is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error retrieving recent memories for patient '{patient_id}': {e}")
-		raise ActionFailed("A database error occurred while retrieving recent memories.") from e
-
-def search_memories_semantic(
-	patient_id: str,
-	query_embedding: list[float],
-	limit: int = 5,
-	*,
-	collection_name: str = Collections.MEDICAL_MEMORY
-) -> list[SemanticSearchResult]:
-	"""Searches memory summaries using semantic similarity with embeddings."""
-	try:
-		obj_patient_id = ObjectId(patient_id)
-		collection = get_collection(collection_name)
-
-		# In a real-world scenario, this would be an Atlas Vector Search query.
-		# This implementation fetches all docs and calculates similarity in the client.
-		docs = list(collection.find({
-			"patient_id": obj_patient_id,
-			"embedding": {"$exists": True}
-		}))
-
-		if not docs:
-			return []
-
-		query_vec = np.array(query_embedding, dtype="float32")
-		results = []
-		for doc in docs:
-			doc_vec = np.array(doc["embedding"], dtype="float32")
-
-			# Calculate cosine similarity
-			dot_product = np.dot(query_vec, doc_vec)
-			norm_query = np.linalg.norm(query_vec)
-			norm_doc = np.linalg.norm(doc_vec)
-
-			if norm_query > 0 and norm_doc > 0:
-				similarity = float(dot_product / (norm_query * norm_doc))
-				result_data = {
-					"summary": doc["summary"],
-					"similarity_score": similarity,
-					"created_at": doc["created_at"],
-					"session_id": doc.get("session_id")
-				}
-				results.append(SemanticSearchResult.model_validate(result_data))
-
-		# Sort by similarity (highest first) and return top results
-		results.sort(key=lambda x: x.similarity_score, reverse=True)
-		return results[:limit]
-	except InvalidId as e:
-		logger().error(f"Invalid patient_id format for semantic search: '{patient_id}'")
-		raise ActionFailed("The provided patient ID is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error during semantic search for patient '{patient_id}': {e}")
-		raise ActionFailed("A database error occurred during the semantic search.") from e

src/data/repositories/medical_record.py

@@ -1,93 +0,0 @@
-# src/data/repositories/medical_record.py
-"""
-Medical record management operations for MongoDB.
-Medical records are structured, factual pieces of information about a patient.
-
-## Fields
-	_id: index
-	patient_id: The patient this record belongs to
-	doctor_id: The doctor who created or is associated with this record
-	record_type: The category of the record (e.g., 'Consultation', 'LabResult')
-	details: An object containing the specific, structured data for the record
-	created_at: The timestamp when the record was created
-	updated_at: The timestamp when the record was last modified
-"""
-
-from datetime import datetime, timezone
-from typing import Any
-
-from bson import ObjectId
-from bson.errors import InvalidId
-from pymongo import ASCENDING
-from pymongo.errors import ConnectionFailure, PyMongoError, WriteError
-
-from src.data.connection import (ActionFailed, Collections, get_collection,
-                                 setup_collection)
-from src.models.medical import MedicalRecord
-from src.utils.logger import logger
-
-
-def init(
-	*,
-	collection_name: str = Collections.MEDICAL_RECORDS,
-	validator_path: str = "schemas/medical_record_validator.json",
-	drop: bool = False
-):
-	"""Initializes the medical_records collection, applying schema validation."""
-	try:
-		if drop:
-			get_collection(collection_name).drop()
-		setup_collection(collection_name, validator_path)
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Failed to initialize collection '{collection_name}': {e}")
-		raise ActionFailed(f"Database operation failed during initialization: {e}") from e
-
-def create_medical_record(
-	patient_id: str,
-	doctor_id: str,
-	record_type: str,
-	details: dict[str, Any],
-	*,
-	collection_name: str = Collections.MEDICAL_RECORDS
-) -> str:
-	"""Creates a new medical record, raising ActionFailed on error."""
-	now = datetime.now(timezone.utc)
-	try:
-		collection = get_collection(collection_name)
-		record_data = {
-			"patient_id": ObjectId(patient_id),
-			"doctor_id": ObjectId(doctor_id),
-			"record_type": record_type,
-			"details": details,
-			"created_at": now,
-			"updated_at": now
-		}
-		result = collection.insert_one(record_data)
-		return str(result.inserted_id)
-	except InvalidId as e:
-		logger().error(f"Invalid ObjectId format provided for medical record: {e}")
-		raise ActionFailed("Patient ID or Doctor ID is not a valid format.") from e
-	except (WriteError, ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Failed to create medical record: {e}")
-		raise ActionFailed("A database error occurred while creating the medical record.") from e
-
-def get_records_for_patient(
-	patient_id: str,
-	*,
-	collection_name: str = Collections.MEDICAL_RECORDS
-) -> list[MedicalRecord]:
-	"""Retrieves all medical records for a patient, sorted by creation date."""
-	try:
-		obj_patient_id = ObjectId(patient_id)
-		collection = get_collection(collection_name)
-		cursor = collection.find(
-			{"patient_id": obj_patient_id}
-		).sort("created_at", ASCENDING)
-
-		return [MedicalRecord.model_validate(doc) for doc in cursor]
-	except InvalidId as e:
-		logger().error(f"Invalid patient_id format for get_records_for_patient: '{patient_id}'")
-		raise ActionFailed("The provided patient ID is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error retrieving records for patient '{patient_id}': {e}")
-		raise ActionFailed("A database error occurred while retrieving medical records.") from e

src/data/repositories/patient.py

@@ -1,176 +0,0 @@
-# src/data/repositories/patient.py
-"""
-Patient management operations for MongoDB.
-A patient is a person who has been assigned to a doctor for treatment.
-
-## Fields
-	_id: index
-	name: The name of the patient
-	age: How old the patient is
-	sex: Male or female
-	ethnicity: Geneological information
-	address: Where they live
-	phone: What their phone number is
-	email: What their email address it
-	medications: Any medications they are currently taking
-	past_assessment_summary: Summarisation of past assessments
-	assigned_doctor_id: The id of the account assigned to this patient
-	created_at: The timestamp when the patient was created
-	updated_at: The timestamp when the patient data was last modified
-"""
-
-import re
-from datetime import datetime, timezone
-from typing import Any
-
-from bson import ObjectId
-from bson.errors import InvalidId
-from pymongo import ASCENDING
-from pymongo.errors import ConnectionFailure, PyMongoError, WriteError
-
-from src.data.connection import (ActionFailed, Collections, get_collection,
-                                 setup_collection)
-from src.models.patient import Patient
-from src.utils.logger import logger
-
-
-def init(
-	*,
-	collection_name: str = Collections.PATIENT,
-	validator_path: str = "schemas/patient_validator.json",
-	drop: bool = False
-):
-	"""Initializes the collection, applying schema and indexes."""
-	try:
-		if drop:
-			get_collection(collection_name).drop()
-		setup_collection(collection_name, validator_path)
-		get_collection(collection_name).create_index("assigned_doctor_id")
-		logger("Init").info(f"Created index on assigned_doctor_id in '{collection_name}'")
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Failed to initialize collection '{collection_name}': {e}")
-		raise ActionFailed(f"Database operation failed during initialization: {e}") from e
-
-def create_patient(
-	name: str,
-	age: int,
-	sex: str,
-	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,
-	*,
-	collection_name: str = Collections.PATIENT
-) -> str:
-	"""Creates a new patient record, raising ActionFailed on error."""
-	now = datetime.now(timezone.utc)
-	patient_data = {
-		"name": name,
-		"age": age,
-		"sex": sex,
-		"created_at": now,
-		"updated_at": now
-	}
-	# Add optional fields to the dictionary
-	if ethnicity: patient_data["ethnicity"] = ethnicity
-	if address: patient_data["address"] = address
-	if phone: patient_data["phone"] = phone
-	if email: patient_data["email"] = email
-	if medications: patient_data["medications"] = medications
-	if past_assessment_summary: patient_data["past_assessment_summary"] = past_assessment_summary
-
-	try:
-		collection = get_collection(collection_name)
-		if assigned_doctor_id:
-			patient_data["assigned_doctor_id"] = ObjectId(assigned_doctor_id)
-
-		result = collection.insert_one(patient_data)
-		return str(result.inserted_id)
-	except InvalidId as e:
-		logger().error(f"Invalid assigned_doctor_id format: '{assigned_doctor_id}'")
-		raise ActionFailed(f"The assigned doctor ID is not a valid format.") from e
-	except WriteError as e:
-		logger().error(f"Failed to create patient due to validation or write error: {e}")
-		raise ActionFailed(f"Patient could not be created due to invalid data.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error while creating patient: {e}")
-		raise ActionFailed(f"A database error occurred while creating the patient.") from e
-
-def get_patient_by_id(
-	patient_id: str,
-	*,
-	collection_name: str = Collections.PATIENT
-) -> Patient | None:
-	"""Gets a patient by ID. Returns a Pydantic Patient object or None."""
-	logger().info(f"Searching for patient with id '{patient_id}'")
-	try:
-		obj_patient_id = ObjectId(patient_id)
-		collection = get_collection(collection_name)
-		patient_dict = collection.find_one({"_id": obj_patient_id})
-
-		if patient_dict:
-			return Patient.model_validate(patient_dict)
-		return None
-	except InvalidId as e:
-		logger().error(f"Invalid patient_id format for get: '{patient_id}'")
-		raise ActionFailed(f"The provided patient ID '{patient_id}' is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error in get_patient_by_id for ID '{patient_id}': {e}")
-		raise ActionFailed(f"A database error occurred while retrieving the patient.") from e
-
-# TODO Make this more rigidly typed, maybe merge with create_patient?
-def update_patient_profile(
-	patient_id: str,
-	updates: dict[str, Any],
-	*,
-	collection_name: str = Collections.PATIENT
-) -> int:
-	"""Updates a patient's profile, raising ActionFailed on error."""
-	try:
-		obj_patient_id = ObjectId(patient_id)
-		collection = get_collection(collection_name)
-		updates["updated_at"] = datetime.now(timezone.utc)
-
-		result = collection.update_one(
-			{"_id": obj_patient_id},
-			{"$set": updates}
-		)
-		return result.modified_count
-	except InvalidId as e:
-		logger().error(f"Invalid patient_id format for update: '{patient_id}'")
-		raise ActionFailed(f"The provided patient ID '{patient_id}' is not a valid format.") from e
-	except WriteError as e:
-		logger().error(f"Failed to update patient '{patient_id}' due to validation or write error: {e}")
-		raise ActionFailed(f"Patient profile could not be updated due to invalid data.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error in update_patient_profile for ID '{patient_id}': {e}")
-		raise ActionFailed(f"A database error occurred while updating the patient profile.") from e
-
-def search_patients(
-	query: str,
-	limit: int = 10,
-	*,
-	collection_name: str = Collections.PATIENT
-) -> list[Patient]:
-	"""Searches patients by name, returning a list of Pydantic Patient objects."""
-	if not query:
-		return []
-
-	logger().info(f"Searching patients with query: '{query}', limit: {limit}")
-	pattern = re.compile(re.escape(query), re.IGNORECASE)
-
-	try:
-		collection = get_collection(collection_name)
-		cursor = collection.find({
-			"name": {"$regex": pattern}
-		}).sort("name", ASCENDING).limit(limit)
-
-		patients = [Patient.model_validate(doc) for doc in cursor]
-		logger().info(f"Found {len(patients)} patients matching query")
-		return patients
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error during patient search for query '{query}': {e}")
-		raise ActionFailed(f"A database error occurred during the patient search.") from e

src/data/repositories/session.py

@@ -1,289 +0,0 @@
-# src/data/repositories/session.py
-"""
-Chat session management operations for MongoDB.
-A session is owned by an account and is related to a patient.
-A session contains many messages.
-
-## Fields
-	_id: index
-	account_id: The user account who owns this session
-	patient_id: The patient being discussed in this session
-	title: The title of this session
-	created_at: When this session was created
-	updated_at: When this session was updated, new message or title
-	messages: An array of messages sent in this session
-		messages._id: index, the order the messages were sent
-		messages.sent_by_user: Whether or not this was sent by the user or the ai
-		messages.content: The actual contents of the message
-		messages.timestamp: When the message was sent
-"""
-
-from datetime import datetime, timedelta, timezone
-from typing import Any
-
-from bson import ObjectId
-from bson.errors import InvalidId
-from pymongo import DESCENDING
-from pymongo.errors import ConnectionFailure, PyMongoError, WriteError
-
-from src.data.connection import (ActionFailed, Collections, get_collection,
-                                 setup_collection)
-from src.models.session import Message, Session
-from src.utils.logger import logger
-
-
-def init(
-	*,
-	collection_name: str = Collections.SESSION,
-	validator_path: str = "schemas/session_validator.json",
-	drop: bool = False
-):
-	"""Initializes the collection, applying schema and indexes."""
-	try:
-		if drop:
-			get_collection(collection_name).drop()
-		setup_collection(collection_name, validator_path)
-		get_collection(collection_name).create_index("messages._id")
-		logger("Init").info(f"Created index on messages._id in '{collection_name}'")
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Failed to initialize collection '{collection_name}': {e}")
-		raise ActionFailed(f"Database operation failed during initialization: {e}") from e
-
-def create_session(
-	account_id: str,
-	patient_id: str,
-	title: str,
-	*,
-	collection_name: str = Collections.SESSION
-) -> Session:
-	"""Creates a new chat session, returning a Pydantic Session object."""
-	now = datetime.now(timezone.utc)
-	try:
-		collection = get_collection(collection_name)
-		session_data: dict[str, Any] = {
-			"account_id": ObjectId(account_id),
-			"patient_id": ObjectId(patient_id),
-			"title": title,
-			"created_at": now,
-			"updated_at": now,
-			"messages": []
-		}
-		result = collection.insert_one(session_data)
-
-		# Retrieve the newly created document to ensure all data is consistent
-		created_doc = collection.find_one({"_id": result.inserted_id})
-		if not created_doc:
-			raise ActionFailed("Failed to retrieve session immediately after creation.")
-
-		return Session.model_validate(created_doc)
-	except InvalidId as e:
-		logger().error(f"Invalid ObjectId format provided for session creation: {e}")
-		raise ActionFailed("Account ID or Patient ID is not a valid format.") from e
-	except (WriteError, ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Failed to create chat session: {e}")
-		raise ActionFailed("A database error occurred while creating the session.") from e
-
-def get_user_sessions(
-	account_id: str,
-	limit: int = 20,
-	*,
-	collection_name: str = Collections.SESSION
-) -> list[Session]:
-	"""Retrieves sessions for a user, returning a list of Pydantic Session objects."""
-	try:
-		obj_account_id = ObjectId(account_id)
-		collection = get_collection(collection_name)
-		cursor = collection.find(
-			{"account_id": obj_account_id}
-		).sort("updated_at", DESCENDING).limit(limit)
-
-		return [Session.model_validate(doc) for doc in cursor]
-	except InvalidId as e:
-		logger().error(f"Invalid account_id format for get_user_sessions: '{account_id}'")
-		raise ActionFailed("The provided account ID is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error listing sessions for account '{account_id}': {e}")
-		raise ActionFailed("A database error occurred while retrieving user sessions.") from e
-
-def list_patient_sessions(
-	patient_id: str,
-	limit: int = 20,
-	*,
-	collection_name: str = Collections.SESSION
-) -> list[Session]:
-	"""Retrieves sessions for a patient, returning a list of Pydantic Session objects."""
-	try:
-		obj_patient_id = ObjectId(patient_id)
-		collection = get_collection(collection_name)
-		cursor = collection.find(
-			{"patient_id": obj_patient_id}
-		).sort("updated_at", DESCENDING).limit(limit)
-
-		return [Session.model_validate(doc) for doc in cursor]
-	except InvalidId as e:
-		logger().error(f"Invalid patient_id format for list_patient_sessions: '{patient_id}'")
-		raise ActionFailed("The provided patient ID is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error listing sessions for patient '{patient_id}': {e}")
-		raise ActionFailed("A database error occurred while retrieving patient sessions.") from e
-
-def get_session(
-	session_id: str,
-	*,
-	collection_name: str = Collections.SESSION
-) -> Session | None:
-	"""Retrieves a session. Returns a Pydantic Session object or None."""
-	try:
-		obj_session_id = ObjectId(session_id)
-		collection = get_collection(collection_name)
-		session_dict = collection.find_one({"_id": obj_session_id})
-
-		if session_dict:
-			return Session.model_validate(session_dict)
-		return None
-	except InvalidId as e:
-		logger().error(f"Invalid session_id format for get_session: '{session_id}'")
-		raise ActionFailed("The provided session ID is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error retrieving session '{session_id}': {e}")
-		raise ActionFailed("A database error occurred while retrieving the session.") from e
-
-def get_session_messages(
-	session_id: str,
-	limit: int | None = None,
-	*,
-	collection_name: str = Collections.SESSION
-) -> list[Message]:
-	"""Gets messages from a session, returning a list of Pydantic Message objects."""
-	try:
-		obj_session_id = ObjectId(session_id)
-		collection = get_collection(collection_name)
-		pipeline = [
-			{"$match": {"_id": obj_session_id}},
-			{"$unwind": "$messages"},
-			{"$sort": {"messages.timestamp": -1}},
-			{"$replaceRoot": {"newRoot": "$messages"}}
-		]
-		if limit:
-			pipeline.append({"$limit": limit})
-
-		message_dicts = list(collection.aggregate(pipeline))
-		return [Message.model_validate(doc) for doc in message_dicts]
-	except InvalidId as e:
-		logger().error(f"Invalid session_id format for get_session_messages: '{session_id}'")
-		raise ActionFailed("The provided session ID is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error retrieving messages for session '{session_id}': {e}")
-		raise ActionFailed("A database error occurred while retrieving messages.") from e
-
-def update_session_title(
-	session_id: str,
-	title: str,
-	*,
-	collection_name: str = Collections.SESSION
-) -> bool:
-	"""Updates a session's title, raising ActionFailed on error."""
-	try:
-		obj_session_id = ObjectId(session_id)
-		collection = get_collection(collection_name)
-		result = collection.update_one(
-			{"_id": obj_session_id},
-			{
-				"$set": {
-					"title": title,
-					"updated_at": datetime.now(timezone.utc)
-				}
-			}
-		)
-		return result.modified_count > 0
-	except InvalidId as e:
-		logger().error(f"Invalid session_id format for update_session_title: '{session_id}'")
-		raise ActionFailed("The provided session ID is not a valid format.") from e
-	except (WriteError, ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error updating title for session '{session_id}': {e}")
-		raise ActionFailed("A database error occurred while updating the session title.") from e
-
-def delete_session(
-	session_id: str,
-	*,
-	collection_name: str = Collections.SESSION
-) -> bool:
-	"""Deletes a session, raising ActionFailed on error."""
-	try:
-		obj_session_id = ObjectId(session_id)
-		collection = get_collection(collection_name)
-		result = collection.delete_one({"_id": obj_session_id})
-		return result.deleted_count > 0
-	except InvalidId as e:
-		logger().error(f"Invalid session_id format for delete_session: '{session_id}'")
-		raise ActionFailed("The provided session ID is not a valid format.") from e
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error deleting session '{session_id}': {e}")
-		raise ActionFailed("A database error occurred while deleting the session.") from e
-
-def prune_old_sessions(
-	days: int = 30,
-	*,
-	collection_name: str = Collections.SESSION
-) -> int:
-	"""Deletes old sessions, raising ActionFailed on error."""
-	try:
-		collection = get_collection(collection_name)
-		cutoff = datetime.now(timezone.utc) - timedelta(days=days)
-		result = collection.delete_many({"updated_at": {"$lt": cutoff}})
-		if result.deleted_count > 0:
-			logger().info(f"Deleted {result.deleted_count} old sessions (>{days} days)")
-		return result.deleted_count
-	except (ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error during session prune: {e}")
-		raise ActionFailed("A database error occurred while pruning old sessions.") from e
-
-def add_message(
-	session_id: str,
-	content: str,
-	sent_by_user: bool,
-	*,
-	collection_name: str = Collections.SESSION
-):
-	"""Adds a message to a session, raising ActionFailed on error."""
-	try:
-		obj_session_id = ObjectId(session_id)
-		collection = get_collection(collection_name)
-
-		session = collection.find_one(
-			{"_id": obj_session_id},
-			{"messages": {"$slice": -1}}
-		)
-		if not session:
-			raise ActionFailed(f"Chat session not found: {session_id}")
-
-		messages = session.get("messages", [])
-		next_id = messages[0]["_id"] + 1 if messages else 0
-		now = datetime.now(timezone.utc)
-		message_data: dict[str, Any] = {
-			"_id": next_id,
-			"sent_by_user": sent_by_user,
-			"content": content,
-			"timestamp": now
-		}
-
-		result = collection.update_one(
-			{"_id": obj_session_id},
-			{
-				"$push": {"messages": message_data},
-				"$set": {"updated_at": now}
-			}
-		)
-
-		if result.modified_count == 0:
-			raise ActionFailed(f"Failed to add message to session, no documents modified: {session_id}")
-
-	except InvalidId as e:
-		logger().error(f"Invalid session_id format for add_message: '{session_id}'")
-		raise ActionFailed("The provided session ID is not a valid format.") from e
-	except ActionFailed as e:
-		logger().warning(str(e))
-		raise
-	except (WriteError, ConnectionFailure, PyMongoError) as e:
-		logger().error(f"Database error adding message to session '{session_id}': {e}")
-		raise ActionFailed("A database error occurred while adding the message.") from e

static/js/app.js

@@ -1290,6 +1290,12 @@ How can I assist you today?`;
     }
 
     updatePatientDisplay(patientId, patientName = null) {
+        // Safety check: don't update display if patientId is undefined or null
+        if (!patientId || patientId === 'undefined' || patientId === 'null') {
+            console.warn('updatePatientDisplay called with invalid patientId:', patientId);
+            return;
+        }
+
         const status = document.getElementById('patientStatus');
         const actions = document.getElementById('patientActions');
         const emrLink = document.getElementById('emrLink');

static/js/emr.js

@@ -101,15 +101,19 @@ class EMRPage {
         const urlParams = new URLSearchParams(window.location.search);
         const patientId = urlParams.get('patient_id');
 
-        if (patientId) {
+        // Check if patientId is valid (not undefined, null, or empty)
+        if (patientId && patientId !== 'undefined' && patientId !== 'null' && patientId.trim() !== '') {
             this.currentPatientId = patientId;
             await this.loadPatientInfo();
         } else {
             // Try to get from localStorage
             const savedPatientId = localStorage.getItem('medicalChatbotPatientId');
-            if (savedPatientId) {
+            if (savedPatientId && savedPatientId !== 'undefined' && savedPatientId !== 'null' && savedPatientId.trim() !== '') {
                 this.currentPatientId = savedPatientId;
                 await this.loadPatientInfo();
+            } else {
+                console.warn('No valid patient ID found in URL or localStorage');
+                this.showEmptyState();
             }
         }
     }