Update app.py

app.py

@@ -32,7 +32,213 @@ app.add_middleware(
 app.include_router(api_router)
 
 # Constants
-BACKEND_URL = "https://rocketfarmstudios-cps-api.hf.space"
+BACKEND_URL = "https://rocketfarmstudios-cps-api.hf.space"  # Update if different backend
+ADMIN_EMAIL = "yakdhanali97@gmail.com"
+ADMIN_PASSWORD = "123456"
+MAX_TOKEN_RETRIES = 3
+TOKEN_RETRY_DELAY = 2  # seconds
+TOKEN_EXPIRY = 3600  # 1 hour default expiry
+
+# Pydantic models
+class LoginPayload(BaseModel):
+    email: str
+    password: str
+
+class DoctorPayload(BaseModel):
+    full_name: str
+    email: str
+    license_number: str
+    password: str
+    specialty: str
+
+class TokenManager:
+    def __init__(self):
+        self.token = None
+        self.last_refresh = 0
+        self.expires_in = TOKEN_EXPIRY
+        self.lock = asyncio.Lock()
+
+    async def _make_login_request(self) -> Optional[str]:
+        try:
+            async with aiohttp.ClientSession() as session:
+                payload = LoginPayload(
+                    email=ADMIN_EMAIL,
+                    password=ADMIN_PASSWORD
+                )
+                login_url = f"{BACKEND_URL.rstrip('/')}/auth/login"
+                logger.debug(f"Sending login request to {login_url} with payload: {payload.dict()}")
+                async with session.post(
+                    login_url,
+                    json=payload.dict(),
+                    timeout=15,
+                    headers={"Content-Type": "application/json"}
+                ) as response:
+                    logger.debug(f"Login response status: {response.status}, URL: {response.url}")
+                    if response.status == 200:
+                        data = await response.json()
+                        token = data.get("access_token")
+                        if not token:
+                            logger.error("No access_token in response")
+                            return None
+                        logger.info(f"Received token: {token[:10]}...")
+                        return token
+                    else:
+                        error = await response.text()
+                        logger.error(f"Login failed: {response.status} - {error}, URL: {response.url}")
+                        return None
+        except aiohttp.ClientError as e:
+            logger.error(f"Login request error: {str(e)}, URL: {login_url}")
+            return None
+
+    async def refresh_token(self) -> str:
+        async with self.lock:
+            for attempt in range(MAX_TOKEN_RETRIES):
+                token = await self._make_login_request()
+                if token:
+                    self.token = token
+                    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)
+
+            raise HTTPException(status_code=500, detail="Failed to obtain admin token after multiple attempts")
+
+    async def get_token(self) -> str:
+        if not self.token or (time.time() - self.last_refresh) > (self.expires_in - 60):
+            return await self.refresh_token()
+        return self.token
+
+token_manager = TokenManager()
+
+@app.get("/")
+def root():
+    logger.debug("Root endpoint accessed")
+    return {"message": "🚀 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):
+    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"
+        }
+        
+        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))
+
+# New 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.lice
+System: I notice the code in the artifact appears incomplete, as it cuts off mid-line in the `/create-doctor` endpoint. I'll provide a corrected and complete version of the updated `app.py` to ensure the `/create-doctor` endpoint and all other functionality are fully implemented. I'll also address the 422 error by ensuring the `TokenManager` sends the correct payload to the `/auth/login` endpoint, based on the Postman test results indicating the backend expects `username` and `password` fields.
+
+### Updated Code with Fixes
+The following code:
+- Updates the `LoginPayload` model to use `username` instead of `email`, matching the backend’s expected schema (based on the 422 error).
+- Completes the `/create-doctor` endpoint.
+- Preserves all other functionality (`/admin`, `/test-backend`, Gradio UI, etc.).
+- Includes environment variable support for `BACKEND_URL` to allow easy configuration.
+- Adds detailed logging to debug payload issues.
+
+<xaiArtifact artifact_id="0bf1081b-f3f2-4a40-9616-4a9b212f1422" artifact_version_id="0b44a4c4-6f14-45b8-bbbe-50e0dded5ed0" title="app.py" contentType="text/python">
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import RedirectResponse
+from api import api_router
+import gradio as gr
+import aiohttp
+import asyncio
+import logging
+import time
+from typing import Optional
+from pydantic import BaseModel
+import os
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+logger.debug("Initializing application")
+
+app = FastAPI()
+
+# CORS Configuration (restrict in production)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(api_router)
+
+# Constants
+BACKEND_URL = os.getenv("BACKEND_URL", "https://rocketfarmstudios-cps-api.hf.space")
 ADMIN_EMAIL = "yakdhanali97@gmail.com"
 ADMIN_PASSWORD = "123456"
 MAX_TOKEN_RETRIES = 3
@@ -43,7 +249,6 @@ TOKEN_EXPIRY = 3600  # 1 hour default expiry
 class LoginPayload(BaseModel):
     username: str
     password: str
-    device_token: str
 
 class DoctorPayload(BaseModel):
     full_name: str
@@ -64,8 +269,7 @@ class TokenManager:
             async with aiohttp.ClientSession() as session:
                 payload = LoginPayload(
                     username=ADMIN_EMAIL,
-                    password=ADMIN_PASSWORD,
-                    device_token="admin-device-token"
+                    password=ADMIN_PASSWORD
                 )
                 login_url = f"{BACKEND_URL.rstrip('/')}/auth/login"
                 logger.debug(f"Sending login request to {login_url} with payload: {payload.dict()}")
@@ -187,7 +391,7 @@ async def async_create_doctor(full_name: str, email: str, license_number: str, s
 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))
 
-# New endpoint for public doctor creation
+# Endpoint for public doctor creation
 @app.post("/create-doctor")
 async def create_doctor(payload: DoctorPayload):
     result = await async_create_doctor(
@@ -265,7 +469,7 @@ with admin_ui:
 
 app = gr.mount_gradio_app(app, admin_ui, path="/admin-auth")
 
-# Modified admin dashboard (no authentication)
+# Admin dashboard (no authentication)
 @app.get("/admin")
 async def admin_dashboard():
     logger.debug("Admin dashboard accessed")