Upload 11 files

main.py

@@ -884,372 +884,469 @@ async def ensure_super_user():
     """
     logger.info("Ensure super user endpoint accessed")
 
+    # First, let's test if we can insert and retrieve data from a simple test table
     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()
+        # Create a simple test table
+        logger.info("Creating test table")
+        app.db_conn.execute("""
+        CREATE TABLE IF NOT EXISTS super_user_test (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            test_value TEXT,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+        """)
+        app.db_conn.commit()
 
-        if existing_user:
-            user_id = existing_user[0]
-            is_admin = existing_user[1] if len(existing_user) > 1 else 0
+        # Insert a test value
+        test_value = f"test_{int(time.time())}"
+        logger.info(f"Inserting test value: {test_value}")
+        app.db_conn.execute("INSERT INTO super_user_test (test_value) VALUES (?)", (test_value,))
+        app.db_conn.commit()
 
-            # 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")
+        # Try to retrieve the test value
+        logger.info("Retrieving test value")
+        result = app.db_conn.execute("SELECT * FROM super_user_test WHERE test_value = ?", (test_value,)).fetchone()
 
-                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
-                }
+        if result:
+            logger.info(f"Test value retrieved successfully: {result}")
+        else:
+            logger.warning("Test value not found after insert")
 
-        # User doesn't exist, create it
-        logger.info("Super user does not exist, creating now")
+        # Get all values from the test table
+        all_test_values = app.db_conn.execute("SELECT * FROM super_user_test").fetchall()
+        logger.info(f"All test values: {all_test_values}")
+    except Exception as e:
+        logger.error(f"Error during test table operations: {str(e)}")
 
-        # Create password hashing context
-        pwd_context = CryptContext(
-            schemes=["argon2"],
-            argon2__time_cost=4,
-            argon2__memory_cost=102400,
-            argon2__parallelism=8,
-            argon2__salt_len=16
-        )
+    # Now let's check the users table schema
+    try:
+        logger.info("Checking users table schema")
+        table_info = app.db_conn.execute("PRAGMA table_info(users)").fetchall()
+        logger.info(f"Users table schema: {table_info}")
+    except Exception as e:
+        logger.error(f"Error checking users table schema: {str(e)}")
 
-        # Hash the password
-        super_user_password = "TestPassword123!"
-        hashed_password = pwd_context.hash(super_user_password)
+    # Let's try a direct SQL approach for creating the super user
+    try:
+        logger.info("Trying direct SQL approach for super user creation")
 
-        # 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
+        # Check if super user exists
+        super_user_email = "[email protected]"
+        direct_check = app.db_conn.execute("SELECT COUNT(*) FROM users WHERE email = ?", (super_user_email,)).fetchone()
+        logger.info(f"Direct check result: {direct_check}")
 
-        # 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 direct_check and direct_check[0] > 0:
+            logger.info("Super user already exists according to direct check")
+        else:
+            logger.info("Super user does not exist according to direct check, 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
+            )
 
-        # 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)}")
+            # Hash the password
+            super_user_password = "TestPassword123!"
+            hashed_password = pwd_context.hash(super_user_password)
 
-        # Add a small delay to ensure the database has processed the insert
-        time.sleep(1)
+            # Try a direct insert with explicit SQL
+            direct_insert = """
+            INSERT INTO users (email, hashed_password, is_admin)
+            VALUES (?, ?, 1)
+            """
+            app.db_conn.execute(direct_insert, (super_user_email, hashed_password))
+            app.db_conn.commit()
+            logger.info("Direct insert completed")
 
-        # 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()
+            # Check if the insert worked
+            direct_verify = app.db_conn.execute("SELECT * FROM users WHERE email = ?", (super_user_email,)).fetchone()
+            logger.info(f"Direct verify result: {direct_verify}")
 
-        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)}")
+            if direct_verify:
+                logger.info("Super user created successfully with direct SQL approach")
+            else:
+                logger.warning("Super user not found after direct SQL insert")
 
-            return {
-                "status": "creation_unverified",
-                "message": "Super user may have been created but could not be verified",
-                "email": super_user_email
-            }
+                # Let's try to list all users
+                all_users = app.db_conn.execute("SELECT * FROM users").fetchall()
+                logger.info(f"All users after direct insert: {all_users}")
     except Exception as e:
-        logger.error(f"Error ensuring super user: {str(e)}")
-        return {
-            "status": "error",
-            "message": f"Error ensuring super user: {str(e)}"
-        }
+        logger.error(f"Error during direct SQL approach: {str(e)}")
+
+    # Return diagnostic information
+    return {
+        "status": "diagnostic_complete",
+        "message": "Diagnostic tests completed. Check server logs for details.",
+        "email": "[email protected]",
+        "next_steps": [
+            "Check server logs for detailed diagnostic information",
+            "Verify database permissions",
+            "Try accessing the /test-db endpoint for additional diagnostics"
+        ]
+    }
 
 # Database test endpoint
 @app.get("/test-db", tags=["General"])
 async def test_database():
     """
-    Test endpoint to verify database operations.
-    This is for debugging purposes only.
-    """
-    import time
+    Test database connectivity and operations.
+    This endpoint performs various database operations to diagnose issues.
 
-    # Generate a unique test ID
-    test_id = f"test_{int(time.time())}"
-    logger.info(f"[{test_id}] Starting database test")
+    Returns:
+        dict: Results of the database tests.
+    """
+    logger.info("Database test endpoint accessed")
 
     results = {
-        "connection_type": getattr(app, "db_type", "unknown"),
-        "connection_object_type": type(app.db_conn).__name__ if hasattr(app, "db_conn") else "None",
-        "operations": []
+        "tests": [],
+        "overall_status": "unknown"
     }
 
-    if hasattr(app, "last_successful_connection_method"):
-        results["connection_method"] = app.last_successful_connection_method
-
-    if not hasattr(app, "db_conn"):
-        logger.error(f"[{test_id}] Database connection not available")
-        results["operations"].append({
-            "name": "Database connection check",
-            "success": False,
-            "error": "Database connection not available"
-        })
-        return results
-
+    # Test 1: Basic connection
     try:
-        # Test 1: Simple SELECT
-        logger.info(f"[{test_id}] Test 1: Simple SELECT")
-        test_query = "SELECT 1 as test"
-        result = app.db_conn.execute(test_query).fetchone()
-        results["operations"].append({
-            "name": "Simple SELECT",
-            "success": result is not None,
-            "result": str(result) if result is not None else None
+        test_result = app.db_conn.execute("SELECT 1").fetchone()
+        results["tests"].append({
+            "name": "basic_connection",
+            "status": "success",
+            "result": str(test_result)
+        })
+    except Exception as e:
+        results["tests"].append({
+            "name": "basic_connection",
+            "status": "failure",
+            "error": str(e)
         })
-        logger.info(f"[{test_id}] Test 1 result: {result}")
 
-        # Test 2: Create a temporary table
-        logger.info(f"[{test_id}] Test 2: Create a temporary table")
-        create_temp_table = """
-        CREATE TABLE IF NOT EXISTS test_table (
+    # Test 2: Create test table
+    try:
+        app.db_conn.execute("""
+        CREATE TABLE IF NOT EXISTS db_test_table (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL,
+            test_value TEXT,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP
         )
-        """
-        app.db_conn.execute(create_temp_table)
+        """)
         app.db_conn.commit()
-        results["operations"].append({
-            "name": "Create temporary table",
-            "success": True
+        results["tests"].append({
+            "name": "create_test_table",
+            "status": "success"
+        })
+    except Exception as e:
+        results["tests"].append({
+            "name": "create_test_table",
+            "status": "failure",
+            "error": str(e)
         })
-        logger.info(f"[{test_id}] Test 2 completed successfully")
 
-        # Test 3: Insert into the temporary table
-        logger.info(f"[{test_id}] Test 3: Insert into the temporary table")
-        test_name = f"test_user_{int(time.time())}"
-        insert_query = "INSERT INTO test_table (name) VALUES (?)"
-        cursor = app.db_conn.execute(insert_query, (test_name,))
+    # Test 3: Insert into test table
+    test_id = int(time.time())
+    test_value = f"test_value_{test_id}"
+    try:
+        app.db_conn.execute("INSERT INTO db_test_table (test_value) VALUES (?)", (test_value,))
         app.db_conn.commit()
+        results["tests"].append({
+            "name": "insert_test_value",
+            "status": "success",
+            "value_inserted": test_value
+        })
+    except Exception as e:
+        results["tests"].append({
+            "name": "insert_test_value",
+            "status": "failure",
+            "error": str(e)
+        })
 
-        # Check if lastrowid is available
-        last_id = None
-        try:
-            last_id = cursor.lastrowid
-            logger.info(f"[{test_id}] Got lastrowid: {last_id}")
-        except Exception as e:
-            logger.warning(f"[{test_id}] Could not get lastrowid: {str(e)}")
+    # Test 4: Retrieve from test table
+    try:
+        result = app.db_conn.execute("SELECT * FROM db_test_table WHERE test_value = ?", (test_value,)).fetchone()
+        if result:
+            results["tests"].append({
+                "name": "retrieve_test_value",
+                "status": "success",
+                "result": str(result)
+            })
+        else:
+            results["tests"].append({
+                "name": "retrieve_test_value",
+                "status": "failure",
+                "error": "Value not found after insert"
+            })
+    except Exception as e:
+        results["tests"].append({
+            "name": "retrieve_test_value",
+            "status": "failure",
+            "error": str(e)
+        })
 
-            # Try to get the ID using a query
+    # Test 5: List all values in test table
+    try:
+        all_values = app.db_conn.execute("SELECT * FROM db_test_table").fetchall()
+        results["tests"].append({
+            "name": "list_all_test_values",
+            "status": "success",
+            "count": len(all_values),
+            "values": str(all_values[-5:]) if all_values else "[]"  # Show only the last 5 values
+        })
+    except Exception as e:
+        results["tests"].append({
+            "name": "list_all_test_values",
+            "status": "failure",
+            "error": str(e)
+        })
+
+    # Test 6: Check users table
+    try:
+        users_count = app.db_conn.execute("SELECT COUNT(*) FROM users").fetchone()
+        results["tests"].append({
+            "name": "check_users_table",
+            "status": "success",
+            "count": users_count[0] if users_count else 0
+        })
+
+        # If users exist, try to get one
+        if users_count and users_count[0] > 0:
             try:
-                id_query = "SELECT id FROM test_table WHERE name = ? ORDER BY id DESC LIMIT 1"
-                id_result = app.db_conn.execute(id_query, (test_name,)).fetchone()
-                if id_result:
-                    last_id = id_result[0]
-                    logger.info(f"[{test_id}] Got ID from query: {last_id}")
-            except Exception as e2:
-                logger.error(f"[{test_id}] Error getting ID from query: {str(e2)}")
-
-        results["operations"].append({
-            "name": "Insert into temporary table",
-            "success": True,
-            "last_id": last_id
+                user = app.db_conn.execute("SELECT * FROM users LIMIT 1").fetchone()
+                results["tests"].append({
+                    "name": "retrieve_user",
+                    "status": "success",
+                    "user_id": user[0] if user else None
+                })
+            except Exception as e:
+                results["tests"].append({
+                    "name": "retrieve_user",
+                    "status": "failure",
+                    "error": str(e)
+                })
+    except Exception as e:
+        results["tests"].append({
+            "name": "check_users_table",
+            "status": "failure",
+            "error": str(e)
         })
-        logger.info(f"[{test_id}] Test 3 completed successfully. Last ID: {last_id}")
-
-        # Test 4: Select from the temporary table
-        logger.info(f"[{test_id}] Test 4: Select from the temporary table")
-        select_query = "SELECT * FROM test_table WHERE name = ?"
-        result = app.db_conn.execute(select_query, (test_name,)).fetchone()
-        results["operations"].append({
-            "name": "Select from temporary table",
-            "success": result is not None,
-            "result": str(result) if result is not None else None
+
+    # Test 7: Try to insert a test user
+    test_user_email = f"test_user_{test_id}@example.com"
+    try:
+        # Create password hashing context
+        pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
+        hashed_password = pwd_context.hash("TestPassword123!")
+
+        # Insert test user
+        app.db_conn.execute(
+            "INSERT INTO users (email, hashed_password, is_admin) VALUES (?, ?, 0)",
+            (test_user_email, hashed_password)
+        )
+        app.db_conn.commit()
+        results["tests"].append({
+            "name": "insert_test_user",
+            "status": "success",
+            "email": test_user_email
         })
-        logger.info(f"[{test_id}] Test 4 result: {result}")
 
-        # Test 5: Check if users table exists and has the expected structure
-        logger.info(f"[{test_id}] Test 5: Check users table structure")
+        # Try to retrieve the test user
         try:
-            table_info = app.db_conn.execute("PRAGMA table_info(users)").fetchall()
-            results["operations"].append({
-                "name": "Check users table structure",
-                "success": len(table_info) > 0,
-                "columns": [col[1] for col in table_info] if table_info else []
-            })
-            logger.info(f"[{test_id}] Test 5 result: {table_info}")
+            user = app.db_conn.execute("SELECT * FROM users WHERE email = ?", (test_user_email,)).fetchone()
+            if user:
+                results["tests"].append({
+                    "name": "retrieve_test_user",
+                    "status": "success",
+                    "user_id": user[0] if user else None
+                })
+            else:
+                results["tests"].append({
+                    "name": "retrieve_test_user",
+                    "status": "failure",
+                    "error": "Test user not found after insert"
+                })
         except Exception as e:
-            logger.error(f"[{test_id}] Error checking users table structure: {str(e)}")
-            results["operations"].append({
-                "name": "Check users table structure",
-                "success": False,
+            results["tests"].append({
+                "name": "retrieve_test_user",
+                "status": "failure",
                 "error": str(e)
             })
+    except Exception as e:
+        results["tests"].append({
+            "name": "insert_test_user",
+            "status": "failure",
+            "error": str(e)
+        })
 
-        # Test 6: List all users
-        logger.info(f"[{test_id}] Test 6: List all users")
-        try:
+    # Calculate overall status
+    success_count = sum(1 for test in results["tests"] if test["status"] == "success")
+    total_count = len(results["tests"])
+
+    if success_count == total_count:
+        results["overall_status"] = "success"
+    elif success_count > 0:
+        results["overall_status"] = "partial_success"
+    else:
+        results["overall_status"] = "failure"
+
+    results["success_rate"] = f"{success_count}/{total_count}"
+
+    return results
+
+# Super user creation endpoint (direct SQL)
+@app.get("/create-super-user", tags=["General"])
+async def create_super_user_endpoint():
+    """
+    Create a super user with email [email protected] directly using SQL.
+    This endpoint is for testing purposes only.
+
+    Returns:
+        dict: Information about the super user creation.
+    """
+    logger.info("Create super user endpoint accessed")
+
+    # Super user details
+    super_user_email = "[email protected]"
+    super_user_password = "TestPassword123!"
+
+    # Create password hashing context
+    pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
+    hashed_password = pwd_context.hash(super_user_password)
+
+    try:
+        # Check if super user already exists
+        logger.info("Checking if super user already exists")
+        existing_user = app.db_conn.execute("SELECT id, is_admin FROM users WHERE email = ?", (super_user_email,)).fetchone()
+
+        if existing_user:
+            user_id = existing_user[0]
+            is_admin = existing_user[1] if len(existing_user) > 1 else 0
+
+            logger.info(f"Super user already exists with ID: {user_id}, is_admin: {is_admin}")
+
+            # If user exists but is not admin, make them admin
+            if not is_admin:
+                logger.info("Updating user to have admin privileges")
+                app.db_conn.execute("UPDATE users SET is_admin = 1 WHERE id = ?", (user_id,))
+                app.db_conn.commit()
+                logger.info("User updated to admin successfully")
+
+                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
+                }
+
+            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
+            }
+
+        # Insert the super user
+        logger.info(f"Inserting super user with email: {super_user_email}")
+        app.db_conn.execute(
+            "INSERT INTO users (email, hashed_password, is_admin) VALUES (?, ?, 1)",
+            (super_user_email, hashed_password)
+        )
+        app.db_conn.commit()
+        logger.info("Super user inserted successfully")
+
+        # Try to retrieve the super user
+        logger.info("Retrieving super user")
+        user = app.db_conn.execute("SELECT * FROM users WHERE email = ?", (super_user_email,)).fetchone()
+
+        if user:
+            logger.info(f"Super user retrieved successfully: {user}")
+            return {
+                "status": "success",
+                "message": "Super user created and retrieved successfully",
+                "user_id": user[0] if user else None,
+                "email": super_user_email
+            }
+        else:
+            logger.warning("Super user not found after insert")
+
+            # Try to list all users
             all_users = app.db_conn.execute("SELECT id, email FROM users").fetchall()
-            results["operations"].append({
-                "name": "List all users",
-                "success": True,
-                "count": len(all_users) if all_users else 0,
-                "users": [{"id": user[0], "email": user[1]} for user in all_users] if all_users else []
-            })
-            logger.info(f"[{test_id}] Test 6 result: {all_users}")
-        except Exception as e:
-            logger.error(f"[{test_id}] Error listing all users: {str(e)}")
-            results["operations"].append({
-                "name": "List all users",
-                "success": False,
-                "error": str(e)
-            })
+            logger.info(f"All users: {all_users}")
 
-        logger.info(f"[{test_id}] Database test completed successfully")
-        return results
+            return {
+                "status": "partial_success",
+                "message": "Super user created but could not be retrieved",
+                "email": super_user_email,
+                "all_users": str(all_users)
+            }
     except Exception as e:
-        logger.error(f"[{test_id}] Database test failed: {str(e)}")
-        results["operations"].append({
-            "name": "Error during tests",
-            "success": False,
-            "error": str(e)
-        })
-        return results
+        logger.error(f"Error creating super user: {str(e)}")
+        return {
+            "status": "error",
+            "message": f"Error creating super user: {str(e)}",
+            "email": super_user_email
+        }
 
 # Test user creation endpoint (direct SQL)
 @app.get("/create-test-user", tags=["General"])
 async def create_test_user():
     """
-    Create a test user with email test@seamo.earth.
-    This is for testing purposes only.
+    Create a test user directly using SQL.
+    This endpoint is for testing purposes only.
 
     Returns:
-        dict: Information about the created test user.
+        dict: Information about the test user creation.
     """
-    import time
-    import subprocess
-    import json
+    logger.info("Create test user endpoint accessed")
+
+    # Generate a unique email
+    test_id = int(time.time())
+    test_email = f"test_user_{test_id}@example.com"
+    test_password = "TestPassword123!"
 
-    # Generate a unique test ID
-    test_id = f"test_{int(time.time())}"
-    logger.info(f"[{test_id}] Starting test user creation (direct SQL)")
+    # Create password hashing context
+    pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
+    hashed_password = pwd_context.hash(test_password)
 
     try:
-        # Run the direct SQL script
-        logger.info(f"[{test_id}] Running direct SQL script")
-        result = subprocess.run(
-            ["python", "direct_sql.py", "create_test_user"],
-            cwd=".",
-            capture_output=True,
-            text=True,
-            check=True
+        # Insert the test user
+        logger.info(f"Inserting test user with email: {test_email}")
+        app.db_conn.execute(
+            "INSERT INTO users (email, hashed_password, is_admin) VALUES (?, ?, 0)",
+            (test_email, hashed_password)
         )
+        app.db_conn.commit()
+        logger.info("Test user inserted successfully")
 
-        # Parse the output
-        try:
-            output = json.loads(result.stdout)
-            logger.info(f"[{test_id}] Direct SQL script result: {output}")
-            return output
-        except json.JSONDecodeError:
-            logger.error(f"[{test_id}] Failed to parse direct SQL script output: {result.stdout}")
+        # Try to retrieve the test user
+        logger.info("Retrieving test user")
+        user = app.db_conn.execute("SELECT * FROM users WHERE email = ?", (test_email,)).fetchone()
+
+        if user:
+            logger.info(f"Test user retrieved successfully: {user}")
             return {
-                "success": False,
-                "error": f"Failed to parse direct SQL script output: {result.stdout}"
+                "status": "success",
+                "message": "Test user created and retrieved successfully",
+                "user_id": user[0] if user else None,
+                "email": test_email
+            }
+        else:
+            logger.warning("Test user not found after insert")
+
+            # Try to list all users
+            all_users = app.db_conn.execute("SELECT id, email FROM users").fetchall()
+            logger.info(f"All users: {all_users}")
+
+            return {
+                "status": "partial_success",
+                "message": "Test user created but could not be retrieved",
+                "email": test_email,
+                "all_users": str(all_users)
             }
-    except subprocess.CalledProcessError as e:
-        logger.error(f"[{test_id}] Direct SQL script failed: {e.stderr}")
-        return {
-            "success": False,
-            "error": f"Direct SQL script failed: {e.stderr}"
-        }
     except Exception as e:
-        logger.error(f"[{test_id}] Error creating test user: {str(e)}")
+        logger.error(f"Error creating test user: {str(e)}")
         return {
-            "success": False,
-            "error": str(e)
+            "status": "error",
+            "message": f"Error creating test user: {str(e)}",
+            "email": test_email
         }
 
 # Direct HTTP API endpoint for user registration