Upload 11 files

main.py

@@ -219,9 +219,39 @@ async def startup_db_client():
             logger.info(f"[{operation_id}] Password hashed successfully")
 
             # Insert the super user with admin privileges
-            insert_query = "INSERT INTO users (email, hashed_password, is_admin) VALUES (?, ?, 1)"
-            cursor = app.db_conn.execute(insert_query, (super_user_email, hashed_password))
-            app.db_conn.commit()
+            # Use a transaction-like approach with multiple commits to ensure it works
+            try:
+                # First try with a transaction
+                logger.info(f"[{operation_id}] Inserting super user with transaction-like approach")
+                insert_query = "INSERT INTO users (email, hashed_password, is_admin) VALUES (?, ?, 1)"
+                cursor = app.db_conn.execute(insert_query, (super_user_email, hashed_password))
+                app.db_conn.commit()
+                logger.info(f"[{operation_id}] Committed super user insert")
+            except Exception as e:
+                logger.error(f"[{operation_id}] Error during super user insert: {str(e)}")
+                # If there was an error, check if it's because the user already exists
+                if "UNIQUE constraint failed" in str(e):
+                    logger.info(f"[{operation_id}] User already exists (UNIQUE constraint)")
+                else:
+                    # If it's another error, try a different approach
+                    try:
+                        logger.info(f"[{operation_id}] Trying alternative insert approach")
+                        # Try to get the highest ID to simulate auto-increment
+                        max_id_result = app.db_conn.execute("SELECT MAX(id) FROM users").fetchone()
+                        logger.info(f"[{operation_id}] Max ID result: {max_id_result}")
+
+                        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, is_admin) VALUES (?, ?, ?, 1)"
+                        cursor = app.db_conn.execute(insert_query, (next_id, super_user_email, hashed_password))
+                        app.db_conn.commit()
+                        logger.info(f"[{operation_id}] Committed super user insert with explicit ID: {next_id}")
+                    except Exception as e2:
+                        logger.error(f"[{operation_id}] Alternative insert approach also failed: {str(e2)}")
+                        raise
 
             # Try to get the user ID
             user_id = None
@@ -231,24 +261,95 @@ async def startup_db_client():
             except Exception as e:
                 logger.warning(f"[{operation_id}] Could not get lastrowid: {str(e)}")
 
-                # If lastrowid is not available, try to get the ID using a query
+            # If we couldn't get the lastrowid, try to get it with a direct query
+            if not user_id or user_id == 0:
                 try:
-                    id_query = "SELECT id FROM users WHERE email = ?"
-                    id_result = app.db_conn.execute(id_query, (super_user_email,)).fetchone()
-                    if id_result:
+                    # Try to get the last inserted ID using a direct query
+                    id_query = "SELECT last_insert_rowid()"
+                    id_result = app.db_conn.execute(id_query).fetchone()
+                    if id_result and id_result[0]:
                         user_id = id_result[0]
-                        logger.info(f"[{operation_id}] Got ID from query: {user_id}")
+                        logger.info(f"[{operation_id}] Got ID from last_insert_rowid(): {user_id}")
                 except Exception as e2:
-                    logger.error(f"[{operation_id}] Error getting ID from query: {str(e2)}")
+                    logger.error(f"[{operation_id}] Error getting ID from last_insert_rowid(): {str(e2)}")
+
+            # Add a small delay to ensure the database has processed the insert
+            time.sleep(1)
 
-            # Verify the super user was created
-            verify_query = "SELECT id, email, is_admin FROM users WHERE email = ?"
-            verify_result = app.db_conn.execute(verify_query, (super_user_email,)).fetchone()
+            # Verify the super user was created with retry
+            max_retries = 3
+            verify_success = False
 
-            if verify_result:
-                logger.info(f"[{operation_id}] Super user created successfully with ID: {verify_result[0]}")
+            for attempt in range(max_retries):
+                try:
+                    logger.info(f"[{operation_id}] Verifying super user creation (attempt {attempt+1})")
+
+                    # If we don't have a user ID yet, try to get it first
+                    if not user_id:
+                        try:
+                            id_query = "SELECT id FROM users WHERE email = ?"
+                            id_result = app.db_conn.execute(id_query, (super_user_email,)).fetchone()
+                            if id_result:
+                                user_id = id_result[0]
+                                logger.info(f"[{operation_id}] Got ID from query: {user_id}")
+                        except Exception as e2:
+                            logger.error(f"[{operation_id}] Error getting ID from query: {str(e2)}")
+
+                    # Verify the super user was created
+                    verify_query = "SELECT id, email, is_admin FROM users WHERE email = ?"
+                    verify_result = app.db_conn.execute(verify_query, (super_user_email,)).fetchone()
+
+                    if verify_result:
+                        logger.info(f"[{operation_id}] Super user verified successfully with ID: {verify_result[0]}")
+                        verify_success = True
+                        break
+                    else:
+                        logger.warning(f"[{operation_id}] Verification attempt {attempt+1} failed, user not found")
+
+                        # Try a different query approach
+                        try:
+                            all_users = app.db_conn.execute("SELECT id, email FROM users").fetchall()
+                            logger.info(f"[{operation_id}] All users in database: {all_users}")
+
+                            # Check if our user is in the list
+                            for user in all_users:
+                                if len(user) > 1 and user[1] == super_user_email:
+                                    logger.info(f"[{operation_id}] Found super user in all users list with ID: {user[0]}")
+                                    verify_success = True
+                                    break
+                        except Exception as e:
+                            logger.error(f"[{operation_id}] Error listing all users: {str(e)}")
+
+                        if verify_success:
+                            break
+
+                        # If this is not the last attempt, wait before retrying
+                        if attempt < max_retries - 1:
+                            time.sleep(2)  # Increase delay between retries
+                except Exception as e:
+                    logger.error(f"[{operation_id}] Error during verification attempt {attempt+1}: {str(e)}")
+                    if attempt < max_retries - 1:
+                        time.sleep(2)
+
+            if verify_success:
+                logger.info(f"[{operation_id}] Super user creation verified successfully")
             else:
-                logger.error(f"[{operation_id}] Failed to verify super user after creation")
+                # Even if verification failed, the user might still have been created
+                # Try one more approach - insert again and catch the unique constraint violation
+                try:
+                    logger.info(f"[{operation_id}] Trying to insert again to check if user exists")
+                    app.db_conn.execute(insert_query, (super_user_email, hashed_password))
+                    app.db_conn.commit()
+                    logger.info(f"[{operation_id}] Second insert succeeded, which is unexpected")
+                except Exception as e:
+                    if "UNIQUE constraint failed" in str(e):
+                        logger.info(f"[{operation_id}] UNIQUE constraint violation confirms user exists")
+                        verify_success = True
+                    else:
+                        logger.error(f"[{operation_id}] Second insert failed with unexpected error: {str(e)}")
+
+                if not verify_success:
+                    logger.error(f"[{operation_id}] Failed to verify super user after creation")
 
         except Exception as e:
             logger.error(f"[{operation_id}] Error creating super user: {str(e)}")
@@ -771,6 +872,182 @@ async def health_check():
         "database_type": getattr(app, "db_type", "unknown")
     }
 
+# Super user check/create endpoint
+@app.get("/ensure-super-user", tags=["General"])
+async def ensure_super_user():
+    """
+    Check if the super user exists and create it if it doesn't.
+    This endpoint can be used to manually trigger super user creation.
+
+    Returns:
+        dict: Information about the super user status.
+    """
+    logger.info("Ensure super user endpoint accessed")
+
+    try:
+        # Check if super user exists
+        super_user_email = "[email protected]"
+        query = "SELECT id, is_admin FROM users WHERE email = ?"
+        existing_user = app.db_conn.execute(query, (super_user_email,)).fetchone()
+
+        if existing_user:
+            user_id = existing_user[0]
+            is_admin = existing_user[1] if len(existing_user) > 1 else 0
+
+            # If user exists but is not admin, make them admin
+            if not is_admin:
+                update_query = "UPDATE users SET is_admin = 1 WHERE id = ?"
+                app.db_conn.execute(update_query, (user_id,))
+                app.db_conn.commit()
+                logger.info(f"Updated user {user_id} to have admin privileges")
+
+                return {
+                    "status": "updated",
+                    "message": f"Super user already existed with ID {user_id} and was updated to have admin privileges",
+                    "user_id": user_id,
+                    "email": super_user_email
+                }
+            else:
+                return {
+                    "status": "exists",
+                    "message": f"Super user already exists with ID {user_id} and has admin privileges",
+                    "user_id": user_id,
+                    "email": super_user_email
+                }
+
+        # User doesn't exist, create it
+        logger.info("Super user does not exist, creating now")
+
+        # Create password hashing context
+        pwd_context = CryptContext(
+            schemes=["argon2"],
+            argon2__time_cost=4,
+            argon2__memory_cost=102400,
+            argon2__parallelism=8,
+            argon2__salt_len=16
+        )
+
+        # Hash the password
+        super_user_password = "TestPassword123!"
+        hashed_password = pwd_context.hash(super_user_password)
+
+        # Insert the super user with admin privileges
+        # Use a transaction-like approach with multiple commits to ensure it works
+        try:
+            # First try with a transaction
+            logger.info("Inserting super user with transaction-like approach")
+            insert_query = "INSERT INTO users (email, hashed_password, is_admin) VALUES (?, ?, 1)"
+            cursor = app.db_conn.execute(insert_query, (super_user_email, hashed_password))
+            app.db_conn.commit()
+            logger.info("Committed super user insert")
+        except Exception as e:
+            logger.error(f"Error during super user insert: {str(e)}")
+            # If there was an error, check if it's because the user already exists
+            if "UNIQUE constraint failed" in str(e):
+                logger.info("User already exists (UNIQUE constraint)")
+                # Try to get the user ID
+                id_query = "SELECT id FROM users WHERE email = ?"
+                id_result = app.db_conn.execute(id_query, (super_user_email,)).fetchone()
+                if id_result:
+                    user_id = id_result[0]
+                    logger.info(f"Found existing user with ID: {user_id}")
+                    cursor = None  # Set cursor to None to indicate we didn't insert
+            else:
+                # If it's another error, try a different approach
+                try:
+                    logger.info("Trying alternative insert approach")
+                    # Try to get the highest ID to simulate auto-increment
+                    max_id_result = app.db_conn.execute("SELECT MAX(id) FROM users").fetchone()
+                    logger.info(f"Max ID result: {max_id_result}")
+
+                    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, is_admin) VALUES (?, ?, ?, 1)"
+                    cursor = app.db_conn.execute(insert_query, (next_id, super_user_email, hashed_password))
+                    app.db_conn.commit()
+                    logger.info(f"Committed super user insert with explicit ID: {next_id}")
+                except Exception as e2:
+                    logger.error(f"Alternative insert approach also failed: {str(e2)}")
+                    raise
+
+        # Try to get the user ID
+        user_id = None
+        try:
+            user_id = cursor.lastrowid
+            logger.info(f"Got lastrowid: {user_id}")
+        except Exception as e:
+            logger.warning(f"Could not get lastrowid: {str(e)}")
+
+        # If we couldn't get the lastrowid or it's 0, try alternative methods
+        if not user_id or user_id == 0:
+            try:
+                # Try to get the last inserted ID using a direct query
+                id_query = "SELECT last_insert_rowid()"
+                id_result = app.db_conn.execute(id_query).fetchone()
+                if id_result and id_result[0]:
+                    user_id = id_result[0]
+                    logger.info(f"Got ID from last_insert_rowid(): {user_id}")
+            except Exception as e2:
+                logger.error(f"Error getting ID from last_insert_rowid(): {str(e2)}")
+
+            # If still no ID, try to get it by email
+            if not user_id or user_id == 0:
+                try:
+                    id_query = "SELECT id FROM users WHERE email = ?"
+                    id_result = app.db_conn.execute(id_query, (super_user_email,)).fetchone()
+                    if id_result:
+                        user_id = id_result[0]
+                        logger.info(f"Got ID from query by email: {user_id}")
+                except Exception as e2:
+                    logger.error(f"Error getting ID from query by email: {str(e2)}")
+
+        # Add a small delay to ensure the database has processed the insert
+        time.sleep(1)
+
+        # Verify the super user was created
+        verify_query = "SELECT id, email, is_admin FROM users WHERE email = ?"
+        verify_result = app.db_conn.execute(verify_query, (super_user_email,)).fetchone()
+
+        if verify_result:
+            return {
+                "status": "created",
+                "message": f"Super user created successfully with ID {verify_result[0]}",
+                "user_id": verify_result[0],
+                "email": super_user_email
+            }
+        else:
+            # Try to list all users to see if our user is there
+            try:
+                all_users = app.db_conn.execute("SELECT id, email FROM users").fetchall()
+                logger.info(f"All users in database: {all_users}")
+
+                # Check if our user is in the list
+                for user in all_users:
+                    if len(user) > 1 and user[1] == super_user_email:
+                        return {
+                            "status": "created_found_in_list",
+                            "message": f"Super user created and found in user list with ID {user[0]}",
+                            "user_id": user[0],
+                            "email": super_user_email
+                        }
+            except Exception as e:
+                logger.error(f"Error listing all users: {str(e)}")
+
+            return {
+                "status": "creation_unverified",
+                "message": "Super user may have been created but could not be verified",
+                "email": super_user_email
+            }
+    except Exception as e:
+        logger.error(f"Error ensuring super user: {str(e)}")
+        return {
+            "status": "error",
+            "message": f"Error ensuring super user: {str(e)}"
+        }
+
 # Database test endpoint
 @app.get("/test-db", tags=["General"])
 async def test_database():