Update app.py

app.py

@@ -11,6 +11,9 @@ import time
 from typing import Optional
 from pydantic import BaseModel
 import os
+from db.mongo import users_collection
+from core.security import hash_password
+from datetime import datetime
 
 # Configure logging
 logging.basicConfig(
@@ -101,7 +104,7 @@ class TokenManager:
                     self.last_refresh = time.time()
                     logger.info("Successfully refreshed admin token")
                     return token
-                
+
                 wait_time = min(5, (attempt + 1) * TOKEN_RETRY_DELAY)
                 logger.warning(f"Attempt {attempt + 1} failed, retrying in {wait_time}s...")
                 await asyncio.sleep(wait_time)
@@ -118,88 +121,44 @@ token_manager = TokenManager()
 @app.get("/")
 def root():
     logger.debug("Root endpoint accessed")
-    return {"message": "🚀 FastAPI with MongoDB + JWT is running."}
+    return {"message": "\ud83d\ude80 FastAPI with MongoDB + JWT is running."}
 
 @app.post("/login")
 async def redirect_login(request: Request):
     logger.info("Redirecting /login to /auth/login")
     return RedirectResponse(url="/auth/login", status_code=307)
 
-async def async_create_doctor(full_name: str, email: str, license_number: str, specialty: str, password: str):
+# NEW PUBLIC DOCTOR CREATION ENDPOINT (NO AUTH REQUIRED)
+@app.post("/public/create-doctor")
+async def create_doctor_public(payload: DoctorPayload):
     try:
-        # Validate inputs
-        if not all([full_name, email, license_number, specialty, password]):
-            logger.error("Doctor creation failed: All fields are required")
-            raise HTTPException(status_code=422, detail="All fields are required")
-
-        token = await token_manager.get_token()
-        
-        payload = DoctorPayload(
-            full_name=full_name,
-            email=email,
-            license_number=license_number,
-            password=password,
-            specialty=specialty
-        )
-        headers = {
-            "Authorization": f"Bearer {token}",
-            "Content-Type": "application/json"
+        logger.info(f"[PUBLIC] Creating doctor: {payload.email}")
+        email = payload.email.strip().lower()
+        existing = await users_collection.find_one({"email": email})
+        if existing:
+            raise HTTPException(status_code=409, detail="Email already exists")
+
+        hashed_pw = hash_password(payload.password)
+        doctor_doc = {
+            "email": email,
+            "full_name": payload.full_name.strip(),
+            "password": hashed_pw,
+            "role": "doctor",
+            "specialty": payload.specialty,
+            "license_number": payload.license_number,
+            "created_at": datetime.utcnow().isoformat(),
+            "updated_at": datetime.utcnow().isoformat(),
+            "device_token": ""
         }
-        
-        doctor_url = f"{BACKEND_URL.rstrip('/')}/auth/admin/doctors"
-        logger.debug(f"Sending doctor creation request to {doctor_url} with payload: {payload.dict()}")
-        async with aiohttp.ClientSession() as session:
-            async with session.post(
-                doctor_url,
-                json=payload.dict(),
-                headers=headers,
-                timeout=15
-            ) as response:
-                logger.debug(f"Doctor creation response status: {response.status}, URL: {response.url}")
-                if response.status == 201:
-                    return "✅ Doctor created successfully!"
-                elif response.status == 401:
-                    logger.warning("Token expired, attempting refresh...")
-                    token = await token_manager.refresh_token()
-                    headers["Authorization"] = f"Bearer {token}"
-                    async with session.post(
-                        doctor_url,
-                        json=payload.dict(),
-                        headers=headers,
-                        timeout=15
-                    ) as retry_response:
-                        logger.debug(f"Retry doctor creation response status: {retry_response.status}, URL: {retry_response.url}")
-                        if retry_response.status == 201:
-                            return "✅ Doctor created successfully!"
-                        error_detail = await retry_response.text()
-                        return f"❌ Error: {error_detail} (Status: {retry_response.status})"
-                
-                error_detail = await response.text()
-                return f"❌ Error: {error_detail} (Status: {response.status})"
-                
-    except HTTPException as e:
-        logger.error(f"Doctor creation failed: {str(e)}")
-        return f"❌ Error: {str(e)}"
-    except Exception as e:
-        logger.error(f"Doctor creation failed: {str(e)}")
-        return f"❌ System Error: {str(e)}"
-
-def sync_create_doctor(full_name: str, email: str, license_number: str, specialty: str, password: str):
-    return asyncio.run(async_create_doctor(full_name, email, license_number, specialty, password))
+        result = await users_collection.insert_one(doctor_doc)
+        logger.info(f"[PUBLIC] Doctor inserted successfully: {email}")
+        return {"status": "success", "id": str(result.inserted_id), "email": email}
 
-# Endpoint for public doctor creation
-@app.post("/create-doctor")
-async def create_doctor(payload: DoctorPayload):
-    result = await async_create_doctor(
-        full_name=payload.full_name,
-        email=payload.email,
-        license_number=payload.license_number,
-        specialty=payload.specialty,
-        password=payload.password
-    )
-    return {"result": result}
-
-# Test endpoint to verify backend connectivity
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"[PUBLIC] Failed to create doctor: {str(e)}")
+        raise HTTPException(status_code=500, detail="Failed to create doctor")point to verify backend connectivity
 @app.get("/test-backend")
 async def test_backend():
     try: