Upload 11 files

main.py

@@ -2,6 +2,7 @@ import os
 import sys
 import logging
 import requests
+import time
 from fastapi import FastAPI, HTTPException, Depends, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
@@ -9,6 +10,8 @@ from fastapi.openapi.utils import get_openapi
 from fastapi.staticfiles import StaticFiles
 import uvicorn
 from dotenv import load_dotenv
+from passlib.context import CryptContext
+from pydantic import BaseModel, EmailStr
 
 # Configure logging
 logging.basicConfig(
@@ -163,6 +166,96 @@ async def startup_db_client():
     else:
         logger.info("Auth token has the expected JWT format")
 
+    # Function to create a super user if it doesn't exist
+    def create_super_user():
+        """
+        Create a super user with admin privileges if it doesn't exist.
+        Uses the email [email protected] as specified.
+        """
+        # Generate a unique identifier for this operation
+        operation_id = f"create_super_user_{int(time.time())}"
+        logger.info(f"[{operation_id}] Starting super user creation check")
+
+        # Password hashing context
+        pwd_context = CryptContext(
+            schemes=["argon2"],
+            argon2__time_cost=4,
+            argon2__memory_cost=102400,
+            argon2__parallelism=8,
+            argon2__salt_len=16
+        )
+
+        # Super user details
+        super_user_email = "[email protected]"
+        super_user_password = "TestPassword123!"  # This is just a default password
+
+        try:
+            # Check if super user already exists
+            logger.info(f"[{operation_id}] Checking if super user already exists")
+            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
+
+                logger.info(f"[{operation_id}] 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(f"[{operation_id}] Updating user to have admin privileges")
+                    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"[{operation_id}] User updated to admin successfully")
+
+                return
+
+            # User doesn't exist, create it
+            logger.info(f"[{operation_id}] Super user does not exist, creating now")
+
+            # Hash the password
+            hashed_password = pwd_context.hash(super_user_password)
+            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()
+
+            # Try to get the user ID
+            user_id = None
+            try:
+                user_id = cursor.lastrowid
+                logger.info(f"[{operation_id}] Got lastrowid: {user_id}")
+            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
+                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 created successfully with ID: {verify_result[0]}")
+            else:
+                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)}")
+            # We'll continue even if super user creation fails
+            # This allows the server to start and function without a super user
+            logger.warning(f"[{operation_id}] Continuing server startup despite super user creation error")
+
     # Initialize database connection
     connected = False
 
@@ -566,6 +659,9 @@ async def startup_db_client():
         logger.info("Journals table created successfully")
 
         logger.info("All database tables created successfully")
+
+        # Create super user if it doesn't exist
+        create_super_user()
     except Exception as e:
         error_msg = f"Failed to create database tables: {str(e)}"
         logger.error(error_msg)
@@ -886,10 +982,6 @@ async def direct_register(request: Request):
     Register a new user using direct HTTP API.
     This is a workaround for issues with the libsql-experimental driver.
     """
-    import time
-    import json
-    from pydantic import BaseModel, EmailStr
-
     class UserCreate(BaseModel):
         email: EmailStr
         password: str
@@ -976,7 +1068,6 @@ async def direct_register(request: Request):
 
         # Hash the password
         logger.info(f"[{request_id}] Hashing password")
-        from passlib.context import CryptContext
         pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
         hashed_password = pwd_context.hash(user.password)
         logger.info(f"[{request_id}] Password hashed successfully")