fix this

app/api/endpoints/v1/firebaseauth/app.py

@@ -1,17 +1,40 @@
+from app import router
 from fastapi import FastAPI, Depends, HTTPException, status, Request, APIRouter
-from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from fastapi.security import OAuth2PasswordBearer
 import firebase_admin
 from firebase_admin import credentials, auth
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select
 from app.models.api.user import UserCreate, UserSignIn, PasswordReset, TokenVerify, UserResponse
 from app.models.database.DBUser import DBUser
-import datetime
-import os
-from app.core.database.session_manager import get_db_session as get_db
-from pydantic import BaseModel, EmailStr
+from app.core.database.session_manager import get_db
 
-router = APIRouter(prefix="/FirebaseAuth", tags=["FirebaseAuth related APIs"])
+import os 
+# Initialize OAuth2 scheme
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/FirebaseAuth/signin")
+
+async def verify_firebase_token(token: str = Depends(oauth2_scheme)) -> dict:
+    """Verify Firebase token and return user info"""
+    try:
+        # Verify the token
+        decoded_token = auth.verify_id_token(token)
+        user_id = decoded_token["uid"]
+        
+        # Get user from Firebase
+        firebase_user = auth.get_user(user_id)
+        
+        return {
+            "firebase_uid": user_id,
+            "email": firebase_user.email,
+            "email_verified": firebase_user.email_verified,
+            "display_name": firebase_user.display_name
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication token",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
 
 # Initialize Firebase Admin SDK with better error handling
 try:
@@ -40,38 +63,6 @@ except Exception as e:
     print(f"Firebase initialization error: {str(e)}")
     # Continue without crashing, but auth functions will fail
 
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/FirebaseAuth/signin")
-async def get_current_user(token: str = Depends(oauth2_scheme), db: AsyncSession = Depends(get_db)):
-    try:
-        decoded_token = auth.verify_id_token(token)
-        user_id = decoded_token["uid"]
-        
-        # Get the Firebase user
-        firebase_user = auth.get_user(user_id)
-        
-        result = await db.execute(select(DBUser).filter(DBUser.firebase_uid == user_id))
-        db_user = result.scalar_one_or_none()
-        
-        if db_user is None:
-            raise HTTPException(status_code=404, detail="User not found in database")
-        
-        return UserResponse(
-            firebase_uid=db_user.firebase_uid,
-            email=db_user.email,
-            display_name=db_user.display_name,
-            is_active=db_user.is_active,
-            created_at=db_user.created_at,
-            last_login=db_user.last_login,
-            provider=db_user.provider,
-            email_verified=firebase_user.email_verified
-        )
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=f"Invalid authentication credentials: {str(e)}",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-
 @router.post("/signup", response_model=dict)
 async def create_user(user_data: UserCreate, db: AsyncSession = Depends(get_db)):
     """Create a new user with email and password and store in database"""
@@ -151,69 +142,74 @@ async def create_user(user_data: UserCreate, db: AsyncSession = Depends(get_db))
 
 @router.post("/signin", response_model=dict)
 async def signin_user(user_data: UserSignIn, db: AsyncSession = Depends(get_db)):
-    """Sign in a user with email and password"""
+    """Sign in user and return token"""
     try:
-        try:
-            firebase_user = auth.get_user_by_email(user_data.email)
-        except auth.UserNotFoundError:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail=f"No user found with email: {user_data.email}"
-            )
+        # Verify user exists in Firebase
+        firebase_user = auth.get_user_by_email(user_data.email)
         
-        # Generate a custom token that can be exchanged for an ID token
+        # Generate custom token
         custom_token = auth.create_custom_token(firebase_user.uid)
         
-        # Update last login time
-        result = await db.execute(select(DBUser).filter(DBUser.firebase_uid == firebase_user.uid))
+        # Update last login in database
+        result = await db.execute(
+            select(DBUser).filter(DBUser.firebase_uid == firebase_user.uid)
+        )
         db_user = result.scalar_one_or_none()
         
-        if not db_user:
-            # Create db user if not exists
-            db_user = DBUser(
-                firebase_uid=firebase_user.uid,
-                email=firebase_user.email,
-                display_name=firebase_user.display_name or user_data.email.split('@')[0],
-                is_active=True,
-                created_at=datetime.datetime.utcnow(),
-                last_login=datetime.datetime.utcnow(),
-                provider="email"
-            )
-            db.add(db_user)
-        else:
+        if db_user:
             db_user.last_login = datetime.datetime.utcnow()
-            
-        await db.commit()
-        await db.refresh(db_user)
-        
-        user_info = {
-            "firebase_uid": db_user.firebase_uid,
-            "email": db_user.email,
-            "display_name": db_user.display_name,
-            "is_active": db_user.is_active,
-            "created_at": db_user.created_at.isoformat() if db_user.created_at else None,
-            "last_login": db_user.last_login.isoformat() if db_user.last_login else None,
-            "provider": db_user.provider,
-            "email_verified": firebase_user.email_verified,
-            "custom_token": custom_token.decode("utf-8") if isinstance(custom_token, bytes) else custom_token
-        }
+            await db.commit()
         
         return {
-            "message": "Login successful",
-            "user": user_info,
-            "custom_token": custom_token.decode("utf-8") if isinstance(custom_token, bytes) else custom_token,
-            "email_verified": firebase_user.email_verified
+            "access_token": custom_token.decode() if isinstance(custom_token, bytes) else custom_token,
+            "token_type": "bearer",
+            "user": {
+                "firebase_uid": firebase_user.uid,
+                "email": firebase_user.email,
+                "email_verified": firebase_user.email_verified,
+                "display_name": firebase_user.display_name
+            }
         }
     except Exception as e:
-        if isinstance(e, HTTPException):
-            raise e
-        await db.rollback()
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail=f"Authentication failed: {str(e)}"
         )
-class EmailVerifyRequest(BaseModel):
-    email: EmailStr
+
+# Example of a protected endpoint
+@router.get("/me", response_model=dict)
+async def get_current_user(
+    current_user: dict = Depends(verify_firebase_token),
+    db: AsyncSession = Depends(get_db)
+):
+    """Get current user information"""
+    try:
+        result = await db.execute(
+            select(DBUser).filter(DBUser.firebase_uid == current_user["firebase_uid"])
+        )
+        db_user = result.scalar_one_or_none()
+        
+        if not db_user:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="User not found in database"
+            )
+            
+        return {
+            "message": "User authenticated",
+            "user": {
+                "firebase_uid": db_user.firebase_uid,
+                "email": db_user.email,
+                "display_name": db_user.display_name,
+                "is_active": db_user.is_active,
+                "email_verified": current_user["email_verified"]
+            }
+        }
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
 
 @router.post("/resend-verification", status_code=status.HTTP_200_OK)
 async def resend_verification_email(