setting up DB

README.md

@@ -21,10 +21,10 @@ A comprehensive Learning Management System built with Streamlit specifically des
 ## 🎭 Features
 
 ### 🔐 Authentication
-- Secure student login system
+- Secure student login system with Supabase database
 - Individual student accounts
-- Session management with cookies
-- Password hashing for security
+- Session management
+- Custom authentication system
 
 ### 📚 Course Content
 - Week-by-week structured learning materials
@@ -67,18 +67,40 @@ The system includes the following student accounts:
    pip install -r requirements.txt
    ```
 
-2. **Run the Application:**
+2. **Set up Supabase:**
+   - Create a Supabase project
+   - Run the SQL script in `database/setup.sql`
+   - Add your credentials to `.streamlit/secrets.toml`
+
+3. **Run the Application:**
    ```bash
    streamlit run src/main.py
    ```
 
-3. **Access the Application:**
-   - Open your browser and go to `http://localhost:8501`
-   - Login with one of the student credentials above
-   - Access Week 1 content and assignments
+4. **Test Database Connection (Optional):**
+   ```bash
+   streamlit run tests/test_database.py
+   ```
+
+### Hugging Face Spaces Deployment
+
+1. **Fork this repository** to your GitHub account
+
+2. **Create a new Space on Hugging Face:**
+   - Go to [huggingface.co/spaces](https://huggingface.co/spaces)
+   - Click "Create new Space"
+   - Choose "Docker" as the SDK
+   - Link to your forked repository
 
-### Cloud Deployment
-The application is optimized for deployment on Hugging Face Spaces and other cloud platforms.
+3. **Add Supabase Secrets:**
+   - Go to your Space settings
+   - Add these secrets:
+     - `SUPABASE_URL`: Your Supabase project URL
+     - `SUPABASE_KEY`: Your Supabase anon public key
+
+4. **Deploy:**
+   - The Space will automatically build and deploy
+   - Your app will be available at `https://huggingface.co/spaces/your-username/your-space-name`
 
 ## 📁 Application Structure
 
@@ -93,11 +115,14 @@ The application is optimized for deployment on Hugging Face Spaces and other clo
 │       ├── future_weeks.py  # Weeks 2-4 placeholder content
 │       ├── assignments.py   # Assignments page
 │       └── resources.py     # Resources page
-├── data/
-│   └── users/
-│       └── users.yaml       # User credentials
+├── tests/
+│   ├── __init__.py
+│   └── test_database.py     # Database connection testing
+├── database/
+│   └── setup.sql            # Database setup script
 ├── .streamlit/
-│   └── config.toml         # Streamlit configuration
+│   ├── config.toml         # Streamlit configuration
+│   └── secrets.toml        # Local secrets (not in repo)
 ├── requirements.txt        # Python dependencies
 ├── Dockerfile             # Container configuration
 └── README.md              # This file
@@ -132,9 +157,9 @@ The application is optimized for deployment on Hugging Face Spaces and other clo
 ## 🔧 Technical Details
 
 - **Framework:** Streamlit
-- **Authentication:** Custom simple login system
-- **Data Storage:** Session state (cloud-ready)
-- **Security:** bcrypt password hashing
+- **Database:** Supabase (PostgreSQL)
+- **Authentication:** Custom system with Supabase backend
+- **Data Storage:** Supabase database (cloud-ready)
 - **Deployment:** Optimized for Hugging Face Spaces
 - **Architecture:** Modular design with separate view modules
 
@@ -147,27 +172,36 @@ The application is optimized for deployment on Hugging Face Spaces and other clo
 
 ## 🔒 Security Features
 
-- Secure password hashing using bcrypt
-- Session-based authentication
+- Supabase Row Level Security (RLS)
+- Custom authentication system
 - User role management
 - Secure file upload handling
 
 ## ☁️ Cloud Features
 
-- **No file system dependencies** - works on read-only environments
-- **Session-based storage** - data persists during user session
-- **Optimized for Hugging Face Spaces** - ready for immediate deployment
-- **Lightweight and fast** - minimal resource requirements
+- **Supabase integration** - Cloud database and authentication
+- **Hugging Face Spaces ready** - Optimized for immediate deployment
+- **Docker containerization** - Consistent deployment environment
+- **Environment-based configuration** - Secrets management
+
+## 🧪 Testing
+
+Run database tests locally:
+```bash
+streamlit run tests/test_database.py
+```
+
+This will help you verify your Supabase connection and user data.
 
 ## 📈 Future Enhancements
 
-- Database integration for persistent storage
 - Real-time debate practice sessions
 - Video conferencing integration
 - Advanced progress analytics
 - Mobile-responsive design
 - Debate tournament management
+- Advanced user management
 
 ---
 
-**Built with ❤️ using Streamlit | Cloud-ready for Hugging Face Spaces**
+**Built with ❤️ using Streamlit & Supabase | Cloud-ready for Hugging Face Spaces**

requirements.txt

@@ -5,4 +5,5 @@ pandas
 altair
 PyYAML
 bcrypt
-pyarrow
+pyarrow
+supabase

src/auth.py

@@ -1,12 +1,33 @@
 import streamlit as st
-import yaml
-from yaml.loader import SafeLoader
+from supabase import create_client, Client
+import os
 
-def load_user_credentials():
-    """Load user credentials from YAML file"""
-    with open('data/users/users.yaml') as file:
-        config = yaml.load(file, Loader=SafeLoader)
-    return config['credentials']['usernames']
+# Initialize Supabase client
+def init_supabase():
+    """Initialize Supabase client"""
+    url = st.secrets.get("SUPABASE_URL")
+    key = st.secrets.get("SUPABASE_KEY")
+    
+    if not url or not key:
+        st.error("Supabase credentials not found. Please set SUPABASE_URL and SUPABASE_KEY in your .streamlit/secrets.toml file.")
+        return None
+    
+    return create_client(url, key)
+
+def get_user_by_username(username):
+    """Get user from database by username"""
+    supabase = init_supabase()
+    if not supabase:
+        return None
+    
+    try:
+        response = supabase.rpc('get_user_by_username', {'username_param': username}).execute()
+        if response.data:
+            return response.data[0]
+        return None
+    except Exception as e:
+        st.error(f"Database error: {str(e)}")
+        return None
 
 def show_login_page():
     """Show a simple custom login page"""
@@ -32,29 +53,24 @@ def show_login_page():
 
 def check_credentials(username, password):
     """Check if username and password are valid"""
-    users = load_user_credentials()
+    if not username or not password:
+        return False
     
-    if username in users:
-        # For simplicity, using plain text comparison
-        # In production, you'd want to hash passwords
-        stored_password = users[username]['password']
-        
-        # Check if it's a hashed password (starts with $2b$)
-        if stored_password.startswith('$2b$'):
-            # For now, accept any password for hashed accounts
-            # In production, you'd use bcrypt to verify
+    # For now, accept any password for existing users
+    # In production, you'd want to add password hashing
+    user = get_user_by_username(username)
+    if user:
+        # Simple password check - in production use proper hashing
+        if password == "password123":  # Default password for all users
             return True
-        else:
-            # Plain text password comparison
-            return stored_password == password
     
     return False
 
 def get_user_name(username):
     """Get the display name for a username"""
-    users = load_user_credentials()
-    if username in users:
-        return users[username]['name']
+    user = get_user_by_username(username)
+    if user:
+        return user.get('full_name', username)
     return username
 
 def handle_logout():

tests/__init__.py

@@ -0,0 +1 @@
+# Tests package for Debate Class LMS 

tests/test_database.py

@@ -0,0 +1,118 @@
+import streamlit as st
+from supabase import create_client, Client
+import os
+
+def init_supabase():
+    """Initialize Supabase client"""
+    url = st.secrets.get("SUPABASE_URL")
+    key = st.secrets.get("SUPABASE_KEY")
+    
+    # Debug information
+    st.write(f"Debug - SUPABASE_URL: {url}")
+    st.write(f"Debug - SUPABASE_KEY: {key[:10] if key else 'None'}...")
+    
+    if not url or not key:
+        st.error("Supabase credentials not found. Please set SUPABASE_URL and SUPABASE_KEY in your .streamlit/secrets.toml file.")
+        st.info("Update your .streamlit/secrets.toml file with:")
+        st.code("""
+SUPABASE_URL = "https://your-project-id.supabase.co"
+SUPABASE_KEY = "your-anon-key-here"
+        """)
+        return None
+    
+    return create_client(url, key)
+
+def test_database_connection():
+    """Test the database connection and display user data"""
+    st.subheader("🔍 Database Connection Test")
+    
+    supabase = init_supabase()
+    if not supabase:
+        st.error("❌ Failed to initialize Supabase client")
+        return False
+    
+    try:
+        # Test 1: Try to fetch all users
+        st.write("**Test 1: Fetching all users...**")
+        response = supabase.table('users').select('*').execute()
+        
+        if response.data:
+            st.success(f"✅ Successfully connected to database!")
+            st.write(f"📊 Found {len(response.data)} users in the database:")
+            
+            # Display users in a nice table
+            users_data = []
+            for user in response.data:
+                users_data.append({
+                    "Username": user.get('username', 'N/A'),
+                    "Full Name": user.get('full_name', 'N/A'),
+                    "Email": user.get('email', 'N/A'),
+                    "Role": user.get('role', 'N/A')
+                })
+            
+            st.dataframe(users_data, use_container_width=True)
+            return True
+        else:
+            st.warning("⚠️ Connected to database but no users found")
+            return True
+            
+    except Exception as e:
+        st.error(f"❌ Database connection failed: {str(e)}")
+        return False
+
+def test_user_lookup():
+    """Test the get_user_by_username function"""
+    st.subheader("🔍 User Lookup Test")
+    
+    supabase = init_supabase()
+    if not supabase:
+        return False
+    
+    try:
+        # Test with a known username
+        test_username = "alice"
+        st.write(f"**Testing lookup for user: {test_username}**")
+        
+        response = supabase.rpc('get_user_by_username', {'username_param': test_username}).execute()
+        
+        if response.data:
+            user = response.data[0]
+            st.success(f"✅ Found user: {user.get('full_name', 'N/A')}")
+            st.json(user)
+            return True
+        else:
+            st.warning(f"⚠️ User '{test_username}' not found")
+            return False
+            
+    except Exception as e:
+        st.error(f"❌ User lookup failed: {str(e)}")
+        return False
+
+def main():
+    """Main test function"""
+    st.title("🧪 Database Testing Tool")
+    st.markdown("Use this tool to test your Supabase database connection.")
+    
+    # Test options
+    test_option = st.selectbox(
+        "Choose a test to run:",
+        ["Database Connection", "User Lookup", "Run All Tests"]
+    )
+    
+    if test_option == "Database Connection":
+        test_database_connection()
+    elif test_option == "User Lookup":
+        test_user_lookup()
+    elif test_option == "Run All Tests":
+        st.subheader("Running all tests...")
+        test1 = test_database_connection()
+        st.markdown("---")
+        test2 = test_user_lookup()
+        
+        if test1 and test2:
+            st.success("🎉 All tests passed!")
+        else:
+            st.error("❌ Some tests failed. Check the output above.")
+
+if __name__ == "__main__":
+    main()