Merging duplicate functions in account

src/api/routes/chat.py

@@ -36,11 +36,7 @@ async def chat_endpoint(
 		# Get or create user profile (doctor as current user profile)
 		user_profile = state.memory_system.get_user(request.user_id)
 		if not user_profile:
-			state.memory_system.create_user(
-				role=request.user_role or "Anonymous",
-				user_id=request.user_id,
-				speciality=request.user_specialty or None
-			)
+			state.memory_system.create_user()
 	except Exception as e:
 		logger().error(f"Error retrieving or creating user profile: {e}")
 		logger().error(f"Request data: {request.model_dump()}")

src/api/routes/doctors.py

@@ -2,8 +2,8 @@
 
 from fastapi import APIRouter, HTTPException
 
-from src.data.repositories.account import (create_doctor, get_all_doctors,
-                                           get_doctor_by_name, search_doctors)
+from src.data.repositories.account import (create_account, get_all_accounts,
+                                           get_account_by_name, search_accounts)
 from src.models.user import DoctorCreateRequest
 from src.utils.logger import logger
 
@@ -13,7 +13,7 @@ router = APIRouter(prefix="/doctors", tags=["Doctors"])
 async def get_all_doctors_route(limit: int = 50):
 	try:
 		logger().info(f"GET /doctors limit={limit}")
-		results = get_all_doctors(limit=limit)
+		results = get_all_accounts(limit=limit)
 		logger().info(f"Retrieved {len(results)} doctors")
 		return {"results": results}
 	except Exception as e:
@@ -24,11 +24,10 @@ async def get_all_doctors_route(limit: int = 50):
 async def create_doctor_profile(req: DoctorCreateRequest):
 	try:
 		logger().info(f"POST /doctors name={req.name}")
-		doctor_id = create_doctor(
+		doctor_id = create_account(
 			name=req.name,
 			role=req.role,
-			specialty=req.specialty,
-			medical_roles=req.medical_roles
+			specialty=req.specialty
 		)
 		logger().info(f"Created doctor {req.name} id={doctor_id}")
 		return {"doctor_id": doctor_id, "name": req.name}
@@ -40,7 +39,7 @@ async def create_doctor_profile(req: DoctorCreateRequest):
 async def get_doctor(doctor_name: str):
 	try:
 		logger().info(f"GET /doctors/{doctor_name}")
-		doctor = get_doctor_by_name(doctor_name)
+		doctor = get_account_by_name(doctor_name)
 		if not doctor:
 			raise HTTPException(status_code=404, detail="Doctor not found")
 		return doctor
@@ -54,7 +53,7 @@ async def get_doctor(doctor_name: str):
 async def search_doctors_route(q: str, limit: int = 10):
 	try:
 		logger().info(f"GET /doctors/search q='{q}' limit={limit}")
-		results = search_doctors(q, limit=limit)
+		results = search_accounts(q, limit=limit)
 		logger().info(f"Doctor search returned {len(results)} results")
 		return {"results": results}
 	except Exception as e:

src/api/routes/user.py

@@ -17,23 +17,16 @@ async def create_user_profile(
 	"""Create or update user profile"""
 	try:
 		# Persist to in-memory profile (existing behavior)
-		user = state.memory_system.create_user(user_id=request.user_id, name=request.name)
-		user.set_preference("role", request.role)
-		if request.specialty:
-			user.set_preference("specialty", request.specialty)
-		if request.medical_roles:
-			user.set_preference("medical_roles", request.medical_roles)
+		#state.memory_system.create_user(name=request.name, role=request.role, speciality=request.specialty)
 
 		# Persist to MongoDB accounts collection
 		account_id = create_account(
 			request.name,
 			request.role,
-			request.specialty or None,
-			request.medical_roles or [request.role] if request.role else [],
-			user_id=request.user_id
+			request.specialty
 		)
 
-		return {"message": "User profile created successfully", "user_id": request.user_id, "account_id": account_id}
+		return {"message": "User profile created successfully", "account_id": account_id}
 	except Exception as e:
 		logger().error(f"Error creating user profile: {e}")
 		raise HTTPException(status_code=500, detail=str(e))

src/core/memory.py

@@ -2,7 +2,6 @@
 
 import uuid
 from datetime import datetime, timezone
-from typing import Any
 
 from src.core.profile import UserProfile
 from src.core.session import ChatSession
@@ -21,27 +20,20 @@ class MemoryLRU:
 
 	def create_user(self,
 		name: str = "Anonymous",
-		role: str | None = None,
-		speciality: str | None = None,
-		roles: list[str] = [],
-		preferences: dict[str, Any] = {},
-		*,
-		user_id: str,
+		role: str = "Other",
+		speciality: str | None = None
 	) -> UserProfile:
 		"""Creates a new user profile."""
-		account.create_account(
+		user_id = account.create_account(
 			name=name,
 			role=role,
-			speciality=speciality,
-			roles=roles,
-			preferences=preferences,
-			user_id=user_id
+			specialty=speciality
 		)
 		return UserProfile(user_id, name)
 
 	def get_user(self, user_id: str) -> UserProfile | None:
 		"""Retrieves a user profile by its ID."""
-		data = account.get_user_profile(user_id)
+		data = account.get_account(user_id)
 		return UserProfile.from_dict(data) if data else None
 
 	def create_session(self, user_id: str, title: str = "New Chat") -> str:
@@ -91,14 +83,6 @@ class MemoryLRU:
 		"""Deletes a chat session."""
 		session.delete_session(session_id)
 
-	def set_user_preferences(
-		self,
-		user_id: str,
-		update_data: dict[str, Any]
-	):
-		"""Sets a preference for a user."""
-		account.set_user_preferences(user_id, update_data)
-
 	def add(self, user_id: str, summary: str):
 		"""Adds a medical context summary for a user."""
 		medical.add_medical_context(user_id, summary)

src/data/repositories/account.py

@@ -28,8 +28,21 @@ from src.utils.logger import logger
 
 ACCOUNTS_COLLECTION = "accounts"
 
+VALID_ROLES = [
+	"Doctor",
+	"Healthcare Prof",
+	"Nurse",
+	"Caregiver",
+	"Physicion",
+	"Medical Student",
+	"Other"
+]
+
 def create():
-	create_collection(ACCOUNTS_COLLECTION, "schemas/account_validator.json")
+	create_collection(
+		ACCOUNTS_COLLECTION,
+		"schemas/account_validator.json"
+	)
 
 def get_account_frame(
 	*,
@@ -40,12 +53,9 @@ def get_account_frame(
 
 def create_account(
 	name: str,
-	role: str | None = None,
-	speciality: str | None = None,
-	roles: list[str] = [],
-	preferences: dict[str, Any] = {},
+	role: str,
+	specialty: str | None = None,
 	*,
-	user_id: str,
 	collection_name: str = ACCOUNTS_COLLECTION
 ) -> str:
 	"""
@@ -56,18 +66,15 @@ def create_account(
 	collection = get_collection(collection_name)
 	now = datetime.now(timezone.utc)
 	user_data: dict[str, Any] = {
-		"_id": user_id,
 		"name": name,
 		"role" : role,
-		"speciality": speciality,
-		"medical_roles": roles,
+		"specialty": specialty,
 		"created_at": now,
 		"updated_at": now
 	}
 
 	try:
 		result = collection.insert_one(user_data)
-		set_user_preferences(user_id, preferences)
 		logger().info(f"Created new account: {result.inserted_id}")
 		return str(result.inserted_id)
 	except DuplicateKeyError as e:
@@ -93,12 +100,12 @@ def update_account(
 	)
 	return result.modified_count > 0
 
-def get_user_profile(
+def get_account(
 	user_id: str,
 	/, *,
 	collection_name: str = ACCOUNTS_COLLECTION
 ) -> dict[str, Any] | None:
-	"""Retrieves a user profile by ID and updates their last_seen timestamp."""
+	"""Retrieves an account by ID and updates their last_seen timestamp."""
 	collection = get_collection(collection_name)
 	now = datetime.now(timezone.utc)
 	return collection.find_one_and_update(
@@ -111,93 +118,21 @@ def get_user_profile(
 		return_document=True
 	)
 
-def set_user_preferences(
-	user_id: str,
-	/,
-	preferences: dict[str, Any],
-	*,
-	collection_name: str = ACCOUNTS_COLLECTION
-) -> bool:
-	"""Sets a preference for a user."""
-	try:
-		collection = get_collection(collection_name)
-		preferences = {f"preferences.{key}": value for key, value in preferences}
-		preferences["updated_at"] = datetime.now(timezone.utc)
-		result = collection.update_one(
-			{"_id": user_id},
-			{
-				"$set": preferences
-			}
-		)
-		if result.matched_count == 0:
-			raise EntryNotFound(f"User with ID '{user_id}' not found.")
-
-		return result.modified_count > 0
-	except PyMongoError as e:
-		logger().error(f"An error occurred with the database operation: {e}")
-		return False
-	except EntryNotFound as e:
-		logger().error(e)
-		return False
-
-# TODO Below methods are unverified
-
-def create_doctor(
-	*,
-	name: str,
-	role: str | None = None,
-	specialty: str | None = None,
-	medical_roles: list[str] | None = None
-) -> str:
-	"""Create a new doctor profile"""
-	collection = get_collection(ACCOUNTS_COLLECTION)
-	now = datetime.now(timezone.utc)
-	doctor_doc = {
-		"name": name,
-		"role": role,
-		"specialty": specialty,
-		"medical_roles": medical_roles or [],
-		"created_at": now,
-		"updated_at": now
-	}
-	try:
-		result = collection.insert_one(doctor_doc)
-		logger().info(f"Created new doctor: {name} with id {result.inserted_id}")
-		return str(result.inserted_id)
-	except Exception as e:
-		logger().error(f"Error creating doctor: {e}")
-		raise e
-
-
-def get_doctor_by_name(name: str) -> dict[str, Any] | None:
-	"""Get doctor by name from accounts collection"""
+def get_account_by_name(name: str) -> dict[str, Any] | None:
+	"""Get account by name from accounts collection"""
 	collection = get_collection(ACCOUNTS_COLLECTION)
-	doctor = collection.find_one({
-		"name": name,
-		"role": {
-			"$in": [
-				"Doctor",
-				"Healthcare Prof",
-				"General Practitioner",
-				"Cardiologist",
-				"Pediatrician",
-				"Neurologist",
-				"Dermatologist"
-			]
-		}
-	})
-	if doctor:
-		doctor["_id"] = str(doctor.get("_id")) if doctor.get("_id") else None
-	return doctor
+	account = collection.find_one({"name": name})
+	#if account:
+	#	account["_id"] = str(account.get("_id")) if account.get("_id") else None
+	return account
 
-
-def search_doctors(query: str, limit: int = 10) -> list[dict[str, Any]]:
-	"""Search doctors by name (case-insensitive contains) from accounts collection"""
+def search_accounts(query: str, limit: int = 10) -> list[dict[str, Any]]:
+	"""Search accounts by name (case-insensitive contains) from accounts collection"""
 	collection = get_collection(ACCOUNTS_COLLECTION)
 	if not query:
 		return []
 
-	logger().info(f"Searching doctors with query: '{query}', limit: {limit}")
+	logger().info(f"Searching accounts with query: '{query}', limit: {limit}")
 
 	# Build a regex for name search
 	pattern = re.compile(re.escape(query), re.IGNORECASE)
@@ -221,30 +156,18 @@ def search_doctors(query: str, limit: int = 10) -> list[dict[str, Any]]:
 		for d in cursor:
 			d["_id"] = str(d.get("_id")) if d.get("_id") else None
 			results.append(d)
-		logger().info(f"Found {len(results)} doctors matching query")
+		logger().info(f"Found {len(results)} accounts matching query")
 		return results
 	except Exception as e:
-		logger().error(f"Error in search_doctors: {e}")
+		logger().error(f"Error in search_account: {e}")
 		return []
 
 
-def get_all_doctors(limit: int = 50) -> list[dict[str, Any]]:
+def get_all_accounts(limit: int = 50) -> list[dict[str, Any]]:
 	"""Get all doctors with optional limit from accounts collection"""
 	collection = get_collection(ACCOUNTS_COLLECTION)
 	try:
-		cursor = collection.find({
-			"role": {
-				"$in": [
-					"Doctor",
-					"Healthcare Prof",
-					"General Practitioner",
-					"Cardiologist",
-					"Pediatrician",
-					"Neurologist",
-					"Dermatologist"
-				]
-			}
-		}).sort("name", ASCENDING).limit(limit)
+		cursor = collection.find().sort("name", ASCENDING).limit(limit)
 		results = []
 		for d in cursor:
 			d["_id"] = str(d.get("_id")) if d.get("_id") else None

src/models/user.py

@@ -4,11 +4,14 @@ from pydantic import BaseModel
 
 
 class UserProfileRequest(BaseModel):
-	user_id: str
 	name: str
 	role: str
 	specialty: str | None = None
-	medical_roles: list[str] | None = None
+
+class DoctorCreateRequest(BaseModel):
+	name: str
+	role: str
+	specialty: str | None = None
 
 class PatientCreateRequest(BaseModel):
 	name: str
@@ -31,9 +34,3 @@ class PatientUpdateRequest(BaseModel):
 	medications: list[str] | None = None
 	past_assessment_summary: str | None = None
 	assigned_doctor_id: str | None = None
-
-class DoctorCreateRequest(BaseModel):
-	name: str
-	role: str | None = None
-	specialty: str | None = None
-	medical_roles: list[str] | None = None

tests/mongo_test.py

@@ -51,7 +51,7 @@ class TestMongoDBRepositories(unittest.TestCase):
 		success = account_repo.update_account(user_id, {"name": "Updated Name"}, collection_name=test_coll)
 		self.assertTrue(success)
 
-		profile = account_repo.get_user_profile(user_id, collection_name=test_coll)
+		profile = account_repo.get_account(user_id, collection_name=test_coll)
 		self.assertIsNotNone(profile)
 		self.assertEqual(profile["name"], "Updated Name") # type: ignore