Upload 10 files

app/api/routes/auth_router.py

@@ -98,79 +98,162 @@ async def get_current_user(request: Request, token: str = Depends(oauth2_scheme)
 @router.post("/register", response_model=UserResponse)
 async def register(request: Request, user: UserCreate):
     import logging
+    import time
     logger = logging.getLogger("auth-server")
 
+    # Log the database connection type
+    db_type = getattr(request.app, "db_type", "unknown")
+    logger.info(f"Database connection type: {db_type}")
+
+    # Generate a unique identifier for this registration attempt
+    registration_id = f"reg_{int(time.time())}"
+    logger.info(f"[{registration_id}] Starting registration for email: {user.email}")
+
     try:
-        # Check if user already exists
-        query = "SELECT * FROM users WHERE email = ?"
-        logger.info(f"Checking if user with email {user.email} already exists")
-        existing_user = request.app.db_conn.execute(query, (user.email,)).fetchone()
-        if existing_user:
-            logger.warning(f"User with email {user.email} already exists")
+        # Step 1: Check if user already exists - with retry
+        for attempt in range(3):
+            try:
+                logger.info(f"[{registration_id}] Checking if user already exists (attempt {attempt+1})")
+                query = "SELECT id FROM users WHERE email = ?"
+                existing_user = request.app.db_conn.execute(query, (user.email,)).fetchone()
+                if existing_user:
+                    logger.warning(f"[{registration_id}] User with email {user.email} already exists")
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail="Email already registered"
+                    )
+                logger.info(f"[{registration_id}] User does not exist, proceeding with registration")
+                break
+            except Exception as e:
+                if "HTTPException" in str(type(e)):
+                    raise
+                logger.error(f"[{registration_id}] Error checking if user exists (attempt {attempt+1}): {str(e)}")
+                if attempt == 2:  # Last attempt
+                    raise
+                time.sleep(1)  # Wait before retrying
+
+        # Step 2: Hash the password
+        logger.info(f"[{registration_id}] Hashing password")
+        try:
+            hashed_password = get_password_hash(user.password)
+            logger.info(f"[{registration_id}] Password hashed successfully")
+        except Exception as e:
+            logger.error(f"[{registration_id}] Error hashing password: {str(e)}")
             raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Email already registered"
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Error hashing password: {str(e)}"
             )
 
-        # Hash the password
-        logger.info("Hashing password")
-        hashed_password = get_password_hash(user.password)
+        # Step 3: Insert the new user - with retry
+        user_id = None
+        for attempt in range(3):
+            try:
+                logger.info(f"[{registration_id}] Inserting new user (attempt {attempt+1})")
+
+                # Use a direct approach for HTTP API
+                if db_type == "http-api":
+                    # First, get the highest ID to simulate auto-increment
+                    max_id_result = request.app.db_conn.execute("SELECT MAX(id) FROM users").fetchone()
+                    next_id = 1
+                    if max_id_result and max_id_result[0] is not None:
+                        next_id = int(max_id_result[0]) + 1
+
+                    # Insert with explicit ID
+                    insert_query = "INSERT INTO users (id, email, hashed_password) VALUES (?, ?, ?)"
+                    request.app.db_conn.execute(insert_query, (next_id, user.email, hashed_password))
+                    user_id = next_id
+                else:
+                    # Standard approach for other connection types
+                    insert_query = "INSERT INTO users (email, hashed_password) VALUES (?, ?)"
+                    cursor = request.app.db_conn.execute(insert_query, (user.email, hashed_password))
+                    user_id = getattr(cursor, "lastrowid", None)
+
+                # Commit the transaction
+                request.app.db_conn.commit()
+
+                if user_id:
+                    logger.info(f"[{registration_id}] User inserted successfully with ID: {user_id}")
+                    break
+                else:
+                    logger.warning(f"[{registration_id}] User inserted but couldn't get ID")
+                    # Continue to try to retrieve by email
+                    break
+            except Exception as e:
+                logger.error(f"[{registration_id}] Error inserting user (attempt {attempt+1}): {str(e)}")
+                if attempt == 2:  # Last attempt
+                    raise
+                time.sleep(1)  # Wait before retrying
+
+        # Step 4: Retrieve the newly created user - with retry
+        new_user = None
+        for attempt in range(3):
+            try:
+                # Try by ID if we have it
+                if user_id:
+                    logger.info(f"[{registration_id}] Retrieving user by ID: {user_id} (attempt {attempt+1})")
+                    new_user = request.app.db_conn.execute("SELECT * FROM users WHERE id = ?", (user_id,)).fetchone()
+
+                # If not found by ID, try by email
+                if not new_user:
+                    logger.info(f"[{registration_id}] Retrieving user by email: {user.email} (attempt {attempt+1})")
+                    new_user = request.app.db_conn.execute("SELECT * FROM users WHERE email = ?", (user.email,)).fetchone()
+
+                if new_user:
+                    logger.info(f"[{registration_id}] User retrieved successfully")
+                    break
+                else:
+                    logger.warning(f"[{registration_id}] User not found (attempt {attempt+1})")
+                    if attempt == 2:  # Last attempt
+                        raise Exception("User was created but could not be retrieved")
+                    time.sleep(1)  # Wait before retrying
+            except Exception as e:
+                logger.error(f"[{registration_id}] Error retrieving user (attempt {attempt+1}): {str(e)}")
+                if attempt == 2:  # Last attempt
+                    raise
+                time.sleep(1)  # Wait before retrying
+
+        # Step 5: Construct the response
+        if not new_user:
+            logger.error(f"[{registration_id}] Failed to retrieve user after multiple attempts")
+            # Create a minimal response with what we know
+            return {
+                "id": user_id or 0,
+                "email": user.email,
+                "is_admin": False,
+                "created_at": ""
+            }
 
-        # Insert the new user
-        logger.info(f"Inserting new user with email {user.email}")
-        insert_query = "INSERT INTO users (email, hashed_password) VALUES (?, ?)"
-        cursor = request.app.db_conn.execute(insert_query, (user.email, hashed_password))
-        request.app.db_conn.commit()
+        # Log the user data for debugging
+        logger.info(f"[{registration_id}] User data: {new_user}")
 
-        # Get the last inserted row ID
-        last_row_id = cursor.lastrowid
-        logger.info(f"User inserted with ID: {last_row_id}")
-
-        # Get the newly created user by ID (more reliable than by email)
-        logger.info(f"Retrieving user with ID {last_row_id}")
-        new_user = request.app.db_conn.execute(
-            "SELECT * FROM users WHERE id = ?",
-            (last_row_id,)
-        ).fetchone()
-
-        if new_user is None:
-            logger.error(f"Failed to retrieve newly created user with ID {last_row_id}")
-            # Try to get by email as fallback
-            logger.info(f"Trying to retrieve user by email {user.email}")
-            new_user = request.app.db_conn.execute(
-                "SELECT * FROM users WHERE email = ?",
-                (user.email,)
-            ).fetchone()
-
-            if new_user is None:
-                logger.error(f"Failed to retrieve newly created user with email {user.email}")
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail="User was created but could not be retrieved"
-                )
-
-        # Log the user data for debugging (excluding password)
-        logger.info(f"User retrieved: ID={new_user[0]}, Email={new_user[1]}")
-
-        # Check if the user has the expected fields
-        if len(new_user) < 6:
-            logger.error(f"User record has unexpected format: {new_user}")
-            # Return what we can
+        # Handle different database return formats
+        if isinstance(new_user, dict):
+            # HTTP API might return a dict
             return {
-                "id": new_user[0],
-                "email": new_user[1],
-                "is_admin": False,  # Default value
-                "created_at": str(new_user[3] if len(new_user) > 3 else "")
+                "id": new_user.get("id", 0),
+                "email": new_user.get("email", user.email),
+                "is_admin": bool(new_user.get("is_admin", 0)),
+                "created_at": str(new_user.get("created_at", ""))
+            }
+        elif isinstance(new_user, (list, tuple)):
+            # Standard cursor returns a tuple
+            return {
+                "id": new_user[0] if len(new_user) > 0 else 0,
+                "email": new_user[1] if len(new_user) > 1 else user.email,
+                "is_admin": bool(new_user[5] if len(new_user) > 5 and new_user[5] is not None else 0),
+                "created_at": str(new_user[3] if len(new_user) > 3 and new_user[3] is not None else "")
+            }
+        else:
+            # Fallback for unexpected return type
+            logger.error(f"[{registration_id}] Unexpected user data type: {type(new_user)}")
+            return {
+                "id": user_id or 0,
+                "email": user.email,
+                "is_admin": False,
+                "created_at": ""
             }
-
-        return {
-            "id": new_user[0],
-            "email": new_user[1],
-            "is_admin": bool(new_user[5]) if new_user[5] is not None else False,
-            "created_at": str(new_user[3]) if new_user[3] is not None else ""
-        }
     except Exception as e:
-        logger.error(f"Error during user registration: {str(e)}")
+        logger.error(f"[{registration_id}] Registration failed: {str(e)}")
         if isinstance(e, HTTPException):
             raise
         raise HTTPException(