Unifying doctors and users routes as accounts

src/api/routes/{doctors.py → account.py}

@@ -1,61 +1,61 @@
-# api/routes/doctors.py
+# api/routes/account.py
 
 from fastapi import APIRouter, HTTPException
 
-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.data.repositories.account import (create_account, get_account_by_name,
+                                           get_all_accounts, search_accounts)
+from src.models.user import AccountCreateRequest
 from src.utils.logger import logger
 
-router = APIRouter(prefix="/doctors", tags=["Doctors"])
+router = APIRouter(prefix="/account", tags=["Account"])
 
 @router.get("")
-async def get_all_doctors_route(limit: int = 50):
+async def get_all_accounts_route(limit: int = 50):
 	try:
-		logger().info(f"GET /doctors limit={limit}")
+		logger(tag="All").info(f"GET /account limit={limit}")
 		results = get_all_accounts(limit=limit)
-		logger().info(f"Retrieved {len(results)} doctors")
+		logger().info(f"Retrieved {len(results)} accounts")
 		return {"results": results}
 	except Exception as e:
-		logger().error(f"Error getting all doctors: {e}")
+		logger().error(f"Error getting all accounts: {e}")
 		raise HTTPException(status_code=500, detail=str(e))
 
 @router.post("")
-async def create_doctor_profile(req: DoctorCreateRequest):
+async def create_account_profile(req: AccountCreateRequest):
 	try:
-		logger().info(f"POST /doctors name={req.name}")
-		doctor_id = create_account(
+		logger().info(f"POST /account name={req.name}")
+		account_id = create_account(
 			name=req.name,
 			role=req.role,
 			specialty=req.specialty
 		)
-		logger().info(f"Created doctor {req.name} id={doctor_id}")
-		return {"doctor_id": doctor_id, "name": req.name}
+		logger().info(f"Created account {req.name} id={account_id}")
+		return {"account_id": account_id, "name": req.name}
 	except Exception as e:
-		logger().error(f"Error creating doctor: {e}")
+		logger().error(f"Error creating account: {e}")
 		raise HTTPException(status_code=500, detail=str(e))
 
-@router.get("/{doctor_name}")
-async def get_doctor(doctor_name: str):
+@router.get("/{account_name}")
+async def get_account(account_name: str):
 	try:
-		logger().info(f"GET /doctors/{doctor_name}")
-		doctor = get_account_by_name(doctor_name)
-		if not doctor:
-			raise HTTPException(status_code=404, detail="Doctor not found")
-		return doctor
+		logger(tag="By name").info(f"GET /account/{account_name}")
+		account = get_account_by_name(account_name)
+		if not account:
+			raise HTTPException(status_code=404, detail="account not found")
+		return account
 	except HTTPException:
 		raise
 	except Exception as e:
-		logger().error(f"Error getting doctor: {e}")
+		logger().error(f"Error getting account: {e}")
 		raise HTTPException(status_code=500, detail=str(e))
 
 @router.get("/search")
-async def search_doctors_route(q: str, limit: int = 10):
+async def search_accounts_route(q: str, limit: int = 10):
 	try:
-		logger().info(f"GET /doctors/search q='{q}' limit={limit}")
+		logger().info(f"GET /account/search q='{q}' limit={limit}")
 		results = search_accounts(q, limit=limit)
-		logger().info(f"Doctor search returned {len(results)} results")
+		logger().info(f"account search returned {len(results)} results")
 		return {"results": results}
 	except Exception as e:
-		logger().error(f"Error searching doctors: {e}")
+		logger().error(f"Error searching accounts: {e}")
 		raise HTTPException(status_code=500, detail=str(e))

src/api/routes/user.py

@@ -1,72 +0,0 @@
-# api/routes/user.py
-
-from fastapi import APIRouter, Depends, HTTPException
-
-from src.core.state import MedicalState, get_state
-from src.data.repositories.account import create_account
-from src.models.user import UserProfileRequest
-from src.utils.logger import logger
-
-router = APIRouter(prefix="/users", tags=["Users"])
-
-@router.post("")
-async def create_user_profile(
-	request: UserProfileRequest,
-	state: MedicalState = Depends(get_state)
-):
-	"""Create or update user profile"""
-	try:
-		# Persist to in-memory profile (existing behavior)
-		#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
-		)
-
-		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))
-
-@router.get("/{user_id}")
-async def get_user_profile(
-	user_id: str,
-	state: MedicalState = Depends(get_state)
-):
-	"""Get user profile and sessions"""
-	try:
-		user = state.memory_system.get_user(user_id)
-		if not user:
-			raise HTTPException(status_code=404, detail="User not found")
-
-		sessions = state.memory_system.get_user_sessions(user_id)
-
-		return {
-			"user": {
-				"id": user.user_id,
-				"name": user.name,
-				"role": user.preferences.get("role", "Unknown"),
-				"specialty": user.preferences.get("specialty", ""),
-				"medical_roles": user.preferences.get("medical_roles", []),
-				"created_at": user.created_at,
-				"last_seen": user.last_seen
-			},
-			"sessions": [
-				{
-					"id": session.session_id,
-					"title": session.title,
-					"created_at": session.created_at,
-					"last_activity": session.last_activity,
-					"message_count": len(session.messages)
-				}
-				for session in sessions if session is not None
-			]
-		}
-	except HTTPException:
-		raise
-	except Exception as e:
-		logger().error(f"Error getting user profile: {e}")
-		raise HTTPException(status_code=500, detail=str(e))

src/data/repositories/account.py

@@ -39,6 +39,7 @@ VALID_ROLES = [
 ]
 
 def create():
+	#get_collection(ACCOUNTS_COLLECTION).drop()
 	create_collection(
 		ACCOUNTS_COLLECTION,
 		"schemas/account_validator.json"
@@ -68,7 +69,7 @@ def create_account(
 	user_data: dict[str, Any] = {
 		"name": name,
 		"role" : role,
-		"specialty": specialty,
+		"specialty": specialty or "",
 		"created_at": now,
 		"updated_at": now
 	}
@@ -120,10 +121,12 @@ def get_account(
 
 def get_account_by_name(name: str) -> dict[str, Any] | None:
 	"""Get account by name from accounts collection"""
+	logger().info("Trying to retrieve account: " + name)
 	collection = get_collection(ACCOUNTS_COLLECTION)
 	account = collection.find_one({"name": name})
-	#if account:
-	#	account["_id"] = str(account.get("_id")) if account.get("_id") else None
+	# HACK This somehow stops some unusual bug with creating a new account.
+	if account:
+		account["_id"] = str(account.get("_id")) if account.get("_id") else None
 	return account
 
 def search_accounts(query: str, limit: int = 10) -> list[dict[str, Any]]:

src/main.py

@@ -24,14 +24,13 @@ except Exception as e:
 	logger(tag="env").warning(f"Error loading .env file: {e}")
 
 # Import project modules after trying to load environment variables
+from src.api.routes import account as account_route
 from src.api.routes import audio as audio_route
 from src.api.routes import chat as chat_route
-from src.api.routes import doctors as doctors_route
 from src.api.routes import patients as patients_route
 from src.api.routes import session as session_route
 from src.api.routes import static as static_route
 from src.api.routes import system as system_route
-from src.api.routes import user as user_route
 from src.core.state import MedicalState, get_state
 from src.data.repositories import account as account_repo
 from src.data.repositories import medical as medical_repo
@@ -124,10 +123,9 @@ app.mount("/static", StaticFiles(directory="static"), name="static")
 
 # Include routers
 app.include_router(chat_route.router)
-app.include_router(user_route.router)
 app.include_router(session_route.router)
 app.include_router(patients_route.router)
-app.include_router(doctors_route.router)
+app.include_router(account_route.router)
 app.include_router(system_route.router)
 app.include_router(static_route.router)
 app.include_router(audio_route.router)

src/models/user.py

@@ -3,12 +3,7 @@
 from pydantic import BaseModel
 
 
-class UserProfileRequest(BaseModel):
-	name: str
-	role: str
-	specialty: str | None = None
-
-class DoctorCreateRequest(BaseModel):
+class AccountCreateRequest(BaseModel):
 	name: str
 	role: str
 	specialty: str | None = None

static/js/app.js

@@ -599,7 +599,7 @@ How can I assist you today?`;
             } else {
                 // If doctor not found in local list, try to fetch from backend
                 try {
-                    const resp = await fetch(`/doctors/search?q=${encodeURIComponent(selectedName)}&limit=1`);
+                    const resp = await fetch(`/account/search?q=${encodeURIComponent(selectedName)}&limit=1`);
                     if (resp.ok) {
                         const data = await resp.json();
                         const doctor = data.results && data.results[0];
@@ -968,7 +968,7 @@ How can I assist you today?`;
     async loadDoctors() {
         try {
             // Fetch doctors from MongoDB
-            const resp = await fetch('/doctors');
+            const resp = await fetch('/account');
             if (resp.ok) {
                 const data = await resp.json();
                 this.doctors = data.results || [];
@@ -1004,7 +1004,7 @@ How can I assist you today?`;
 
     async searchDoctors(query) {
         try {
-            const resp = await fetch(`/doctors/search?q=${encodeURIComponent(query)}&limit=10`);
+            const resp = await fetch(`/account/search?q=${encodeURIComponent(query)}&limit=10`);
             if (resp.ok) {
                 const data = await resp.json();
                 return data.results || [];
@@ -1017,7 +1017,7 @@ How can I assist you today?`;
 
     async createDoctor(doctorData) {
         try {
-            const resp = await fetch('/doctors', {
+            const resp = await fetch('/account', {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(doctorData)
@@ -1134,7 +1134,7 @@ How can I assist you today?`;
         // Check if doctor exists in MongoDB first
         let doctorExists = false;
         try {
-            const resp = await fetch(`/doctors/${encodeURIComponent(name)}`);
+            const resp = await fetch(`/account/${encodeURIComponent(name)}`);
             doctorExists = resp.ok;
         } catch (e) {
             console.warn('Failed to check doctor existence:', e);
@@ -1176,7 +1176,7 @@ How can I assist you today?`;
             };
 
             try {
-                const resp = await fetch('/doctors', {
+                const resp = await fetch('/account', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify(doctorPayload)