Upload 12 files

app/api/routes/auth_router.py

@@ -18,12 +18,14 @@ logger = logging.getLogger("auth-server")
 router = APIRouter()
 
 # Password hashing
+# Using a fixed configuration to ensure consistent hash lengths
 pwd_context = CryptContext(
     schemes=["argon2"],
-    argon2__time_cost=4,
-    argon2__memory_cost=102400,
-    argon2__parallelism=8,
-    argon2__salt_len=16
+    argon2__time_cost=3,
+    argon2__memory_cost=65536,
+    argon2__parallelism=4,
+    argon2__salt_len=16,
+    argon2__hash_len=32
 )
 
 # JWT settings
@@ -165,8 +167,66 @@ async def register(request: Request, user: UserCreate):
         # Step 2: Hash the password
         logger.info(f"[{registration_id}] Hashing password")
         try:
+            # Use a fixed configuration to ensure consistent hash length
             hashed_password = get_password_hash(user.password)
-            logger.info(f"[{registration_id}] Password hashed successfully")
+            logger.info(f"[{registration_id}] Password hashed successfully, length: {len(hashed_password)}")
+
+            # Check if we need to fix the database schema
+            if len(hashed_password) != 97:
+                logger.warning(f"[{registration_id}] Password hash length ({len(hashed_password)}) doesn't match expected length (97)")
+                logger.warning(f"[{registration_id}] This might cause issues if there's a CHECK constraint in the database")
+
+                # Try to fix the database schema by removing the constraint
+                try:
+                    # First, check if the users table exists with a simple query
+                    db_http.execute_query(
+                        "SELECT name FROM sqlite_master WHERE type='table' AND name='users'",
+                        operation_id=f"{registration_id}_check_table"
+                    )
+
+                    # Create a temporary table without the constraint
+                    db_http.execute_query(
+                        """
+                        CREATE TABLE IF NOT EXISTS users_temp (
+                            id INTEGER PRIMARY KEY AUTOINCREMENT,
+                            email TEXT NOT NULL UNIQUE,
+                            hashed_password TEXT NOT NULL,
+                            created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                            last_login DATETIME,
+                            is_admin INTEGER DEFAULT 0
+                        )
+                        """,
+                        operation_id=f"{registration_id}_create_temp"
+                    )
+
+                    # Copy data from users to users_temp if users exists
+                    try:
+                        db_http.execute_query(
+                            """
+                            INSERT INTO users_temp (id, email, hashed_password, created_at, last_login, is_admin)
+                            SELECT id, email, hashed_password, created_at, last_login, is_admin FROM users
+                            """,
+                            operation_id=f"{registration_id}_copy_data"
+                        )
+                    except Exception as e:
+                        logger.warning(f"[{registration_id}] Error copying data: {str(e)}")
+
+                    # Drop the original users table
+                    db_http.execute_query(
+                        "DROP TABLE IF EXISTS users",
+                        operation_id=f"{registration_id}_drop_users"
+                    )
+
+                    # Rename users_temp to users
+                    db_http.execute_query(
+                        "ALTER TABLE users_temp RENAME TO users",
+                        operation_id=f"{registration_id}_rename_table"
+                    )
+
+                    logger.info(f"[{registration_id}] Fixed users table schema")
+                except Exception as e:
+                    logger.error(f"[{registration_id}] Error fixing users table: {str(e)}")
+                    # Continue with registration anyway
         except Exception as e:
             logger.error(f"[{registration_id}] Error hashing password: {str(e)}")
             raise HTTPException(

main.py

@@ -488,7 +488,7 @@ async def startup_db_client():
                 """
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 email TEXT NOT NULL UNIQUE,
-                hashed_password TEXT NOT NULL CHECK(LENGTH(hashed_password) = 97),
+                hashed_password TEXT NOT NULL,
                 created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                 last_login DATETIME,
                 is_admin BOOLEAN DEFAULT 0
@@ -2040,6 +2040,90 @@ app.include_router(auth_router.router, prefix="/api/auth", tags=["Authentication
 app.include_router(projects_router.router, prefix="/api/projects", tags=["Projects"])
 app.include_router(journals_router.router, prefix="/api/journals", tags=["Journals"])
 
+# Fix users table endpoint
+@app.get("/fix-users-table", tags=["General"])
+async def fix_users_table():
+    """
+    Fix the users table by recreating it without the CHECK constraint on hashed_password.
+    This endpoint is for fixing database issues.
+
+    Returns:
+        dict: Information about the operation.
+    """
+    logger.info("Fix users table endpoint accessed")
+    operation_id = f"fix_users_table_{int(time.time())}"
+
+    try:
+        # Import the HTTP API utility
+        from app.utils import db_http
+
+        # Step 1: Check if users table exists
+        logger.info(f"[{operation_id}] Checking if users table exists")
+
+        # Step 2: Create a temporary table without the constraint
+        logger.info(f"[{operation_id}] Creating temporary table")
+        db_http.execute_query(
+            """
+            CREATE TABLE IF NOT EXISTS users_temp (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                email TEXT NOT NULL UNIQUE,
+                hashed_password TEXT NOT NULL,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                last_login DATETIME,
+                is_admin INTEGER DEFAULT 0
+            )
+            """,
+            operation_id=f"{operation_id}_create_temp"
+        )
+
+        # Step 3: Copy data from users to users_temp if users exists
+        logger.info(f"[{operation_id}] Copying data to temporary table")
+        try:
+            db_http.execute_query(
+                """
+                INSERT INTO users_temp (id, email, hashed_password, created_at, last_login, is_admin)
+                SELECT id, email, hashed_password, created_at, last_login, is_admin FROM users
+                """,
+                operation_id=f"{operation_id}_copy_data"
+            )
+            logger.info(f"[{operation_id}] Data copied successfully")
+        except Exception as e:
+            logger.warning(f"[{operation_id}] Error copying data: {str(e)}")
+            # This is expected if the users table doesn't exist or is empty
+
+        # Step 4: Drop the original users table
+        logger.info(f"[{operation_id}] Dropping original users table")
+        db_http.execute_query(
+            "DROP TABLE IF EXISTS users",
+            operation_id=f"{operation_id}_drop_users"
+        )
+
+        # Step 5: Rename users_temp to users
+        logger.info(f"[{operation_id}] Renaming temporary table to users")
+        db_http.execute_query(
+            "ALTER TABLE users_temp RENAME TO users",
+            operation_id=f"{operation_id}_rename_table"
+        )
+
+        # Step 6: Create indexes
+        logger.info(f"[{operation_id}] Creating indexes")
+        db_http.execute_query(
+            "CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)",
+            operation_id=f"{operation_id}_create_index"
+        )
+
+        logger.info(f"[{operation_id}] Users table fixed successfully")
+        return {
+            "success": True,
+            "message": "Users table fixed successfully"
+        }
+    except Exception as e:
+        logger.error(f"[{operation_id}] Error fixing users table: {str(e)}")
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
 # Test database with HTTP API endpoint
 @app.get("/test-db-http", tags=["General"])
 async def test_db_http():