Add authentication features and environment configuration

- Create .env.example for environment variables
- Update .gitignore to exclude .env file
- Add python-dotenv to requirements
- Implement PrivateRoute component for protected routes
- Enhance Sidebar and UserMenu components for user authentication
- Update server.py to load environment variables
- Add login_required decorator to theme routes
- Refactor useFetch hook to include authorization token

Author: Eric-Philippe

.env.example

@@ -0,0 +1,2 @@
+USER_ADMIN=admin123
+USER_TEST=test123

.gitignore

@@ -3,4 +3,5 @@
 #
 puzzles/*
 !puzzles/sample
-__pycache__/
+__pycache__/
+.env

app/__init__.py

@@ -4,6 +4,8 @@
 from .utils.loader import PuzzlesLoader
 
 app = Flask(__name__, static_folder='../frontend/dist')
+app.secret_key = 'your_secret_key_here'  # Add a secret key for sessions
+
 loader = PuzzlesLoader()
 
 swagger_config = {
@@ -28,4 +30,4 @@ def serve(path):
     else:
         return send_from_directory(app.static_folder, 'index.html')
 
-from .routes import health, puzzles, themes
+from .routes import health, puzzles, themes, auth

app/auth.py

@@ -0,0 +1,112 @@
+import uuid
+import os
+import hashlib
+import time
+from functools import wraps
+from flask import request, abort, session, jsonify
+
+# In-memory user storage
+users = {}
+sessions = {}
+
+def generate_session_id():
+    return str(uuid.uuid4())
+
+def hash_password(password, salt=None):
+    if salt is None:
+        salt = uuid.uuid4().hex
+    hashed = hashlib.sha256((password + salt).encode()).hexdigest()
+    return f"{salt}:{hashed}"
+
+def check_password(password, hashed_password):
+    salt, hashed = hashed_password.split(":")
+    return hashed == hashlib.sha256((password + salt).encode()).hexdigest()
+
+def register_user(username, password):
+    if username in users:
+        return False, "Username already exists"
+    
+    if len(password) < 5:
+        return False, "Password must be at least 5 characters"
+    
+    users[username] = {
+        "username": username,
+        "password": hash_password(password),
+        "created_at": time.time()
+    }
+    return True, "User registered successfully"
+
+def authenticate_user(username, password):
+    if username not in users:
+        return False, "Invalid username or password"
+    
+    user = users[username]
+    if not check_password(password, user["password"]):
+        return False, "Invalid username or password"
+    
+    session_id = generate_session_id()
+    sessions[session_id] = {
+        "username": username,
+        "created_at": time.time()
+    }
+    
+    return True, session_id
+
+def logout_user(session_id):
+    if session_id in sessions:
+        del sessions[session_id]
+    return True
+
+def delete_user(username):
+    if username in users:
+        del users[username]
+        # Remove any active sessions for this user
+        for session_id in list(sessions.keys()):
+            if sessions[session_id]["username"] == username:
+                del sessions[session_id]
+        return True
+    return False
+
+def is_authenticated(session_id):
+    return session_id in sessions
+
+def get_user_from_session(session_id):
+    if session_id in sessions:
+        username = sessions[session_id]["username"]
+        return users.get(username)
+    return None
+
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        auth_header = request.headers.get("Authorization")
+        
+        if not auth_header or not auth_header.startswith("Bearer "):
+            return jsonify({"error": "Unauthorized"}), 401
+        
+        session_id = auth_header.split("Bearer ")[1]
+        
+        if not is_authenticated(session_id):
+            return jsonify({"error": "Unauthorized"}), 401
+            
+        return f(*args, **kwargs)
+    return decorated_function
+
+def create_user_from_env():
+    """
+    Create users from environment variables.
+    Environment variables should be in the format USER_<username>=<password>
+    """
+    user_count = 0
+    for key, value in os.environ.items():
+        if key.startswith("USER_"):
+            username = key[5:].lower().replace("_", "-")
+            password = value
+            print(f"Registering user {username} with password {password}")
+            register_user(username, password)
+            user_count += 1
+            
+    if user_count == 0:
+        print("No users found in environment variables.")
+        print("Using a default u:{admin} p:{admin} user.")
+        register_user("admin", "admin")    

app/routes/auth.py

@@ -0,0 +1,208 @@
+from flask import request, jsonify
+from .. import app
+from ..auth import register_user, authenticate_user, logout_user, delete_user, get_user_from_session, is_authenticated
+
+@app.route('/auth/register', methods=['POST'])
+def register():
+    """
+    Register a new user
+    ---
+    tags:
+      - Authentication
+    parameters:
+      - name: body
+        in: body
+        required: true
+        schema:
+          type: object
+          properties:
+            username:
+              type: string
+            password:
+              type: string
+    responses:
+      200:
+        description: User registered successfully
+      400:
+        description: Registration failed
+    """
+    data = request.json
+    username = data.get('username')
+    password = data.get('password')
+    
+    if not username or not password:
+        return jsonify({"error": "Username and password are required"}), 400
+    
+    success, message = register_user(username, password)
+    
+    if success:
+        return jsonify({"message": message}), 200
+    else:
+        return jsonify({"error": message}), 400
+
+@app.route('/auth/login', methods=['POST'])
+def login():
+    """
+    Login a user
+    ---
+    tags:
+      - Authentication
+    parameters:
+      - name: body
+        in: body
+        required: true
+        schema:
+          type: object
+          properties:
+            username:
+              type: string
+            password:
+              type: string
+    responses:
+      200:
+        description: Login successful
+      401:
+        description: Login failed
+    """
+    data = request.json
+    username = data.get('username')
+    password = data.get('password')
+    
+    if not username or not password:
+        return jsonify({"error": "Username and password are required"}), 400
+    
+    success, result = authenticate_user(username, password)
+    
+    if success:
+        return jsonify({
+            "message": "Login successful",
+            "token": result,
+            "username": username
+        }), 200
+    else:
+        return jsonify({"error": result}), 401
+
+@app.route('/auth/logout', methods=['POST'])
+def logout():
+    """
+    Logout a user
+    ---
+    tags:
+      - Authentication
+    parameters:
+      - name: Authorization
+        in: header
+        type: string
+        required: true
+        description: Bearer token
+    responses:
+      200:
+        description: Logout successful
+    """
+    auth_header = request.headers.get('Authorization')
+    
+    if not auth_header or not auth_header.startswith('Bearer '):
+        return jsonify({"message": "Logged out"}), 200
+    
+    session_id = auth_header.split('Bearer ')[1]
+    logout_user(session_id)
+    
+    return jsonify({"message": "Logged out successfully"}), 200
+
+@app.route('/auth/user', methods=['GET'])
+def get_user():
+    """
+    Get current user information
+    ---
+    tags:
+      - Authentication
+    parameters:
+      - name: Authorization
+        in: header
+        type: string
+        required: true
+        description: Bearer token
+    responses:
+      200:
+        description: User information
+      401:
+        description: Not authenticated
+    """
+    auth_header = request.headers.get('Authorization')
+    
+    if not auth_header or not auth_header.startswith('Bearer '):
+        return jsonify({"error": "Not authenticated"}), 401
+    
+    session_id = auth_header.split('Bearer ')[1]
+    user = get_user_from_session(session_id)
+    
+    if not user:
+        return jsonify({"error": "Not authenticated"}), 401
+    
+    return jsonify({
+        "username": user["username"],
+        "created_at": user["created_at"]
+    }), 200
+
+@app.route('/auth/delete-account', methods=['DELETE'])
+def delete_account():
+    """
+    Delete user account
+    ---
+    tags:
+      - Authentication
+    parameters:
+      - name: Authorization
+        in: header
+        type: string
+        required: true
+        description: Bearer token
+    responses:
+      200:
+        description: Account deleted successfully
+      401:
+        description: Not authenticated
+    """
+    auth_header = request.headers.get('Authorization')
+    
+    if not auth_header or not auth_header.startswith('Bearer '):
+        return jsonify({"error": "Not authenticated"}), 401
+    
+    session_id = auth_header.split('Bearer ')[1]
+    user = get_user_from_session(session_id)
+    
+    if not user:
+        return jsonify({"error": "Not authenticated"}), 401
+    
+    username = user["username"]
+    if delete_user(username):
+        return jsonify({"message": "Account deleted successfully"}), 200
+    else:
+        return jsonify({"error": "Failed to delete account"}), 400
+
+@app.route('/auth/check', methods=['GET'])
+def check_auth():
+    """
+    Check if user is authenticated
+    ---
+    tags:
+      - Authentication
+    parameters:
+      - name: Authorization
+        in: header
+        type: string
+        required: true
+        description: Bearer token
+    responses:
+      200:
+        description: Authentication status
+    """
+    auth_header = request.headers.get('Authorization')
+    
+    if not auth_header or not auth_header.startswith('Bearer '):
+        return jsonify({"authenticated": False}), 200
+    
+    session_id = auth_header.split('Bearer ')[1]
+    authenticated = is_authenticated(session_id)
+    
+    return jsonify({"authenticated": authenticated}), 200