upload

.dockerignore

@@ -0,0 +1,26 @@
+# Version control
+.git
+.gitignore
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+venv
+.env
+
+# IDE
+.vscode
+.idea
+
+# React frontend
+react-frontend/node_modules
+react-frontend/build
+react-frontend/.env*
+
+# Misc
+.DS_Store
+README.md
+*.log

Dockerfile

@@ -0,0 +1,31 @@
+# Use Python 3.9 slim image as base
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1
+
+# Install system dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Expose the port
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "services.api.db.auth:app", "--host", "0.0.0.0", "--port", "7860"]

requirements.txt

@@ -0,0 +1,29 @@
+# Core dependencies
+fastapi==0.109.2
+uvicorn==0.27.1
+python-multipart==0.0.7
+python-dotenv==1.0.1
+
+# Database
+pymysql==1.1.0
+bcrypt==4.1.2
+SQLAlchemy==2.0.27
+
+# Cloud Services
+boto3==1.34.34
+awscli==1.32.34
+
+# Auth
+python-jose==3.3.0
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+
+# AI/ML
+google-generativeai==0.3.2
+langchain==0.1.4
+langchain-community==0.0.16
+qdrant-client==1.7.0
+sentence-transformers==2.5.1
+
+# Data Processing
+pandas==2.2.0

services/api/api_endpoints.py

@@ -0,0 +1,1853 @@
+from fastapi import APIRouter, Depends, HTTPException, Request, Cookie, UploadFile, File, Form
+from typing import List, Optional, Dict
+from pydantic import BaseModel
+from services.api.db.token_utils import decode_token
+from dotenv import load_dotenv
+import os
+import pymysql
+import pandas as pd
+import boto3
+import json
+from botocore.exceptions import ClientError
+from datetime import datetime
+from fastapi.middleware.cors import CORSMiddleware
+
+# Load environment variables
+load_dotenv()
+MYSQL_USER = os.getenv("MYSQL_USER")
+MYSQL_PASSWORD = os.getenv("MYSQL_PASSWORD")
+MYSQL_HOST = os.getenv("MYSQL_HOST", "localhost")
+MYSQL_DB = os.getenv("MYSQL_DB")
+MYSQL_PORT = int(os.getenv("MYSQL_PORT", "3306"))
+
+# AWS Configuration
+AWS_ACCESS_KEY = os.getenv("AWS_ACCESS_KEY_ID")
+AWS_SECRET_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
+REGION = os.getenv("REGION_NAME", "ap-southeast-1")
+
+# Initialize S3 client
+s3 = boto3.client('s3',
+    aws_access_key_id=AWS_ACCESS_KEY,
+    aws_secret_access_key=AWS_SECRET_KEY,
+    region_name=REGION
+)
+
+router = APIRouter(
+    prefix="/api",
+    tags=["courses"],
+    responses={404: {"description": "Not found"}},
+)
+
+# Simple test endpoint to verify routing
+@router.post("/test")
+async def test_post():
+    return {"message": "POST test endpoint works"}
+
+def connect_db():
+    try:
+        print(f"Connecting to database {MYSQL_DB} on {MYSQL_HOST}:{MYSQL_PORT}")
+        connection = pymysql.connect(
+            host=MYSQL_HOST,
+            user=MYSQL_USER,
+            password=MYSQL_PASSWORD,
+            database=MYSQL_DB,
+            port=MYSQL_PORT
+        )
+        print("Database connection successful")
+        return connection
+    except Exception as e:
+        print(f"Database connection error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Database connection error: {str(e)}")
+
+# Models
+class Course(BaseModel):
+    id: int
+    name: str
+    instructor: str
+    description: Optional[str]
+    rating: Optional[float] = None
+    enrolled: Optional[int] = 0
+
+class QuestionOption(BaseModel):
+    text: str
+    isCorrect: bool = False
+
+class QuizQuestion(BaseModel):
+    question: str
+    options: list[str]
+    correctAnswer: int
+
+class Quiz(BaseModel):
+    title: str
+    description: Optional[str] = None
+    questions: Dict[str, QuizQuestion]
+
+class LectureListItem(BaseModel):
+    id: int
+    title: str
+    courseId: int
+    description: Optional[str] = None
+
+class Lecture(BaseModel):
+    id: int
+    courseId: int
+    title: str
+    description: Optional[str] = None
+    content: Optional[str] = None
+    videoUrl: Optional[str] = None
+    quiz: Optional[Quiz] = None
+    
+class LectureDetails(Lecture):
+    courseName: Optional[str] = None
+    courseDescription: Optional[str] = None
+    courseLectures: Optional[List[LectureListItem]] = None
+
+# Get all courses
+@router.get("/courses", response_model=List[Course])
+async def get_courses(request: Request, auth_token: str = Cookie(None)):
+    try:
+        # Try to get token from Authorization header if cookie is not present
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+        
+        if not auth_token:
+            raise HTTPException(status_code=401, detail="No authentication token provided")
+            
+        # Verify user is authenticated
+        try:
+            user_data = decode_token(auth_token)
+        except Exception as e:
+            print(f"Token decode error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token")
+        
+        conn = connect_db()
+        courses = []
+        
+        try:
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                query = """
+                SELECT 
+                    c.CourseID as id, 
+                    c.CourseName as name, 
+                    CONCAT(i.InstructorName, ' (', i.AccountName, ')') as instructor,
+                    c.Descriptions as description
+                FROM Courses c
+                JOIN Instructors i ON c.InstructorID = i.InstructorID
+                """
+                cursor.execute(query)
+                courses = cursor.fetchall()
+                
+                # Get ratings for each course
+                for course in courses:
+                    cursor.execute("""
+                    SELECT AVG(Rating) as avg_rating, COUNT(*) as count
+                    FROM Enrollments
+                    WHERE CourseID = %s AND Rating IS NOT NULL
+                    """, (course['id'],))
+                    
+                    rating_data = cursor.fetchone()
+                    if rating_data and rating_data['avg_rating']:
+                        course['rating'] = float(rating_data['avg_rating'])
+                    else:
+                        course['rating'] = None
+                        
+                    # Get enrollment count
+                    cursor.execute("""
+                    SELECT COUNT(*) as enrolled
+                    FROM Enrollments
+                    WHERE CourseID = %s
+                    """, (course['id'],))
+                    
+                    enrolled_data = cursor.fetchone()
+                    if enrolled_data:
+                        course['enrolled'] = enrolled_data['enrolled']
+                    else:
+                        course['enrolled'] = 0
+        finally:
+            conn.close()
+            
+        return courses
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Get course details
+@router.get("/courses/{course_id}", response_model=Course)
+async def get_course_details(request: Request, course_id: int, auth_token: str = Cookie(None)):
+    try:
+        # Try to get token from Authorization header if cookie is not present
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+        
+        if not auth_token:
+            raise HTTPException(status_code=401, detail="No authentication token provided")
+            
+        # Verify user is authenticated
+        try:
+            user_data = decode_token(auth_token)
+        except Exception as e:
+            print(f"Token decode error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token")
+        
+        conn = connect_db()
+        course = None
+        
+        try:
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                # First check if course exists
+                query = """
+                SELECT 
+                    c.CourseID as id, 
+                    c.CourseName as name, 
+                    CONCAT(i.InstructorName, ' (', i.AccountName, ')') as instructor,
+                    c.Descriptions as description
+                FROM Courses c
+                JOIN Instructors i ON c.InstructorID = i.InstructorID
+                WHERE c.CourseID = %s
+                """
+                cursor.execute(query, (course_id,))
+                course = cursor.fetchone()
+                
+                if not course:
+                    raise HTTPException(status_code=404, detail=f"Course with ID {course_id} not found")
+                
+                # Get ratings and enrollment count in one query
+                cursor.execute("""
+                SELECT 
+                    COUNT(*) as enrolled,
+                    COALESCE(AVG(Rating), 0) as avg_rating,
+                    COUNT(CASE WHEN Rating IS NOT NULL THEN 1 END) as rating_count
+                FROM Enrollments 
+                WHERE CourseID = %s
+                """, (course_id,))
+                
+                stats = cursor.fetchone()
+                if stats:
+                    course['enrolled'] = stats['enrolled']
+                    course['rating'] = float(stats['avg_rating']) if stats['rating_count'] > 0 else None
+                else:
+                    course['enrolled'] = 0
+                    course['rating'] = None
+                
+        finally:
+            conn.close()
+            
+        return course
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Error in get_course_details: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Get lectures for a course
+@router.get("/courses/{course_id}/lectures", response_model=List[Lecture])
+async def get_course_lectures(request: Request, course_id: int, auth_token: str = Cookie(None)):
+    try:
+        # Try to get token from Authorization header if cookie is not present
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+        
+        if not auth_token:
+            raise HTTPException(status_code=401, detail="No authentication token provided")
+            
+        try:
+            user_data = decode_token(auth_token)
+        except Exception as e:
+            print(f"Token decode error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token")
+        
+        conn = connect_db()
+        lectures = []
+        
+        try:
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                # First verify the course exists
+                cursor.execute("SELECT CourseID FROM Courses WHERE CourseID = %s", (course_id,))
+                if not cursor.fetchone():
+                    raise HTTPException(status_code=404, detail="Course not found")
+
+                query = """
+                SELECT 
+                    LectureID as id, 
+                    CourseID as courseId,
+                    Title as title, 
+                    Description as description
+                FROM Lectures
+                WHERE CourseID = %s
+                ORDER BY LectureID
+                """
+                cursor.execute(query, (course_id,))
+                lectures = cursor.fetchall()
+                
+                # Ensure all fields match the Lecture model
+                for lecture in lectures:
+                    # Ensure the fields exist and have appropriate null values if missing
+                    if lecture.get('description') is None:
+                        lecture['description'] = None
+        finally:
+            conn.close()
+            
+        return lectures
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Error in get_course_lectures: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Get lecture details
+@router.get("/lectures/{lecture_id}", response_model=LectureDetails)
+async def get_lecture_details(request: Request, lecture_id: int, auth_token: str = Cookie(None)):
+    try:
+        # Try to get token from Authorization header if cookie is not present
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+        
+        if not auth_token:
+            raise HTTPException(status_code=401, detail="No authentication token provided")
+            
+        # Verify user is authenticated
+        try:
+            user_data = decode_token(auth_token)
+        except Exception as e:
+            print(f"Token decode error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token")
+        
+        conn = connect_db()
+        try:
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                # Get lecture details with course data
+                query = """
+                SELECT 
+                    l.LectureID as id,
+                    l.CourseID as courseId,
+                    l.Title as title,
+                    l.Description as description,
+                    l.Content as content,
+                    c.CourseName as courseName,
+                    c.CourseID,
+                    c.Descriptions as courseDescription
+                FROM Lectures l
+                JOIN Courses c ON l.CourseID = c.CourseID
+                WHERE l.LectureID = %s
+                """
+                cursor.execute(query, (lecture_id,))
+                lecture = cursor.fetchone()
+                
+                if not lecture:
+                    raise HTTPException(status_code=404, detail="Lecture not found")
+                
+                # Get course lectures
+                cursor.execute("""
+                SELECT 
+                    LectureID as id,
+                    CourseID as courseId,
+                    Title as title,
+                    Description as description
+                FROM Lectures
+                WHERE CourseID = %s
+                ORDER BY LectureID
+                """, (lecture['courseId'],))
+                
+                course_lectures = cursor.fetchall()
+                if not course_lectures:
+                    course_lectures = []
+
+                response_data = {
+                    "id": lecture['id'],
+                    "courseId": lecture['courseId'],
+                    "title": lecture['title'],
+                    "description": lecture['description'],
+                    "content": lecture['content'],
+                    "courseName": lecture['courseName'],
+                    "courseDescription": lecture['courseDescription'],
+                    "courseLectures": course_lectures,
+                    "videoUrl": None,
+                    "quiz": None  # Initialize quiz as None
+                }
+
+                # Get video URL if exists
+                video_path = f"videos/cid{lecture['courseId']}/lid{lecture['id']}/vid_lecture.mp4"
+                try:
+                    s3.head_object(Bucket="tlhmaterials", Key=video_path)
+                    response_data['videoUrl'] = f"https://tlhmaterials.s3-{REGION}.amazonaws.com/{video_path}"
+                except:
+                    pass  # Keep videoUrl as None if no video exists
+
+                # Get quiz if exists - fixing this part
+                cursor.execute("""
+                SELECT q.QuizID, q.Title, q.Description
+                FROM Quizzes q
+                WHERE q.LectureID = %s
+                """, (lecture_id,))
+                
+                quiz_data = cursor.fetchone()
+                if quiz_data:
+                    quiz = {
+                        "id": quiz_data['QuizID'],
+                        "title": quiz_data['Title'],
+                        "description": quiz_data['Description'],
+                        "questions": {}
+                    }
+                    
+                    # Get quiz questions
+                    cursor.execute("""
+                    SELECT 
+                        q.QuestionID, 
+                        q.QuestionText,
+                        o.OptionID,
+                        o.OptionText,
+                        o.IsCorrect
+                    FROM Questions q
+                    JOIN Options o ON q.QuestionID = o.QuestionID
+                    WHERE q.QuizID = %s
+                    ORDER BY q.QuestionID, o.OptionID
+                    """, (quiz_data['QuizID'],))
+                    
+                    questions_data = cursor.fetchall()
+                    current_question_id = None
+                    current_options = []
+                    correct_option_index = 0
+                    
+                    for row in questions_data:
+                        if current_question_id != row['QuestionID']:
+                            # Save previous question data
+                            if current_question_id is not None:
+                                quiz['questions'][str(current_question_id)] = {
+                                    'question': question_text,
+                                    'options': current_options,
+                                    'correctAnswer': correct_option_index
+                                }
+                            
+                            # Start new question
+                            current_question_id = row['QuestionID']
+                            question_text = row['QuestionText']
+                            current_options = []
+                            correct_option_index = 0
+                        
+                        current_options.append(row['OptionText'])
+                        if row['IsCorrect']:
+                            correct_option_index = len(current_options) - 1
+                    
+                    # Save the last question
+                    if current_question_id is not None:
+                        quiz['questions'][str(current_question_id)] = {
+                            'question': question_text,
+                            'options': current_options,
+                            'correctAnswer': correct_option_index
+                        }
+                    
+                    response_data['quiz'] = quiz
+                
+                return response_data
+                
+        finally:
+            conn.close()
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Error in get_lecture_details: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Get instructor's courses
+@router.get("/instructor/courses", response_model=List[Course])
+async def get_instructor_courses(
+    request: Request,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+        
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            username = user_data['username']
+            role = user_data['role']
+            
+            # Verify user is an instructor
+            if role != "Instructor":
+                raise HTTPException(status_code=403, detail="Only instructors can access this endpoint")
+            
+            # Connect to database
+            conn = connect_db()
+            
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                # Get instructor ID
+                cursor.execute("""
+                    SELECT InstructorID 
+                    FROM Instructors 
+                    WHERE AccountName = %s
+                """, (username,))
+                
+                instructor = cursor.fetchone()
+                if not instructor:
+                    raise HTTPException(status_code=404, detail="Instructor not found")
+                
+                instructor_id = instructor['InstructorID']
+                
+                # Get courses by this instructor
+                query = """
+                    SELECT 
+                        c.CourseID as id, 
+                        c.CourseName as name, 
+                        CONCAT(i.InstructorName, ' (', i.AccountName, ')') as instructor,
+                        c.Descriptions as description,
+                        (SELECT COUNT(*) FROM Enrollments WHERE CourseID = c.CourseID) as enrolled,
+                        COALESCE(
+                            (SELECT AVG(Rating) 
+                             FROM Enrollments 
+                             WHERE CourseID = c.CourseID AND Rating IS NOT NULL),
+                            0
+                        ) as rating
+                    FROM Courses c
+                    JOIN Instructors i ON c.InstructorID = i.InstructorID
+                    WHERE c.InstructorID = %s
+                    ORDER BY c.CourseID DESC
+                """
+                
+                cursor.execute(query, (instructor_id,))
+                courses = cursor.fetchall()
+                
+                # Format the courses data
+                formatted_courses = []
+                for course in courses:
+                    formatted_course = {
+                        'id': course['id'],
+                        'name': course['name'],
+                        'instructor': course['instructor'],
+                        'description': course['description'],
+                        'enrolled': course['enrolled'],
+                        'rating': float(course['rating']) if course['rating'] else None
+                    }
+                    formatted_courses.append(formatted_course)
+                
+                return formatted_courses
+                
+        except Exception as e:
+            print(f"Database error: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+            
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Error fetching instructor courses: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+# Create a new course
+class CourseCreate(BaseModel):
+    name: str
+    description: str
+    skills: List[str]
+    difficulty: str
+    duration: Optional[int] = None
+
+@router.post("/instructor/courses", response_model=Course)
+async def create_course(
+    course_data: CourseCreate,
+    request: Request,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+        
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            username = user_data['username']
+            role = user_data['role']
+            
+            # Log debugging information
+            print(f"POST /instructor/courses - User: {username}, Role: {role}")
+            print(f"Course data: {course_data}")
+            
+            # Verify user is an instructor
+            if role != "Instructor":
+                raise HTTPException(status_code=403, detail="Only instructors can create courses")
+            
+            # Connect to database
+            conn = connect_db()
+            
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                # Get instructor ID
+                cursor.execute("""
+                    SELECT InstructorID 
+                    FROM Instructors 
+                    WHERE AccountName = %s
+                """, (username,))
+                
+                instructor = cursor.fetchone()
+                if not instructor:
+                    raise HTTPException(status_code=404, detail="Instructor not found")
+                
+                instructor_id = instructor['InstructorID']
+                
+                # Insert new course
+                cursor.execute("""
+                    INSERT INTO Courses 
+                    (CourseName, Descriptions, Skills, Difficulty, EstimatedDuration, InstructorID) 
+                    VALUES (%s, %s, %s, %s, %s, %s)
+                """, (
+                    course_data.name, 
+                    course_data.description, 
+                    json.dumps(course_data.skills), 
+                    course_data.difficulty, 
+                    course_data.duration or "Self-paced", 
+                    instructor_id
+                ))
+                
+                # Get the created course ID
+                course_id = cursor.lastrowid
+                conn.commit()
+                
+                # Return the created course
+                cursor.execute("""
+                    SELECT 
+                        c.CourseID as id, 
+                        c.CourseName as name, 
+                        CONCAT(i.InstructorName, ' (', i.AccountName, ')') as instructor,
+                        c.Descriptions as description,
+                        0 as enrolled,
+                        NULL as rating
+                    FROM Courses c
+                    JOIN Instructors i ON c.InstructorID = i.InstructorID
+                    WHERE c.CourseID = %s
+                """, (course_id,))
+                
+                new_course = cursor.fetchone()
+                if not new_course:
+                    raise HTTPException(status_code=500, detail="Course was created but couldn't be retrieved")
+                
+                return new_course
+                
+        except Exception as e:
+            if 'conn' in locals():
+                conn.rollback()
+            print(f"Database error: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+            
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Error creating course: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+# Enroll in a course
+@router.post("/courses/{course_id}/enroll")
+async def enroll_in_course(
+    course_id: int,
+    request: Request,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+        
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            
+            # Get LearnerID from Learners table using the username
+            conn = connect_db()
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                cursor.execute("""
+                    SELECT LearnerID 
+                    FROM Learners 
+                    WHERE AccountName = %s
+                """, (user_data['username'],))
+                learner = cursor.fetchone()
+                if not learner:
+                    raise HTTPException(status_code=404, detail="Learner not found")
+                learner_id = learner['LearnerID']
+        except Exception as e:
+            print(f"Token/user verification error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token or user not found")
+
+        # Check if the course exists
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            cursor.execute("""
+                SELECT CourseID 
+                FROM Courses 
+                WHERE CourseID = %s
+            """, (course_id,))
+            course = cursor.fetchone()
+            if not course:
+                raise HTTPException(status_code=404, detail="Course not found")
+            
+            # Check if already enrolled
+            cursor.execute("""
+                SELECT EnrollmentID 
+                FROM Enrollments 
+                WHERE LearnerID = %s AND CourseID = %s
+            """, (learner_id, course_id))
+            existing_enrollment = cursor.fetchone()
+            if existing_enrollment:
+                return {"message": "Already enrolled in this course"}
+            
+            # Get the actual column names from the Enrollments table
+            cursor.execute("DESCRIBE Enrollments")
+            columns = cursor.fetchall()
+            column_names = [col['Field'] for col in columns]
+            print(f"Available columns in Enrollments table: {column_names}")
+            
+            # Enroll the learner in the course with the correct date column
+            try:
+                # Try different common column names for the enrollment date
+                enroll_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                cursor.execute(
+                    "CALL sp_EnrollLearner(%s, %s, %s)",
+                    (learner_id, course_id, enroll_date)
+                )
+                
+                conn.commit()
+                return {"message": "Successfully enrolled in the course"}
+            except Exception as e:
+                conn.rollback()
+                print(f"Error enrolling in course: {str(e)}")
+                raise HTTPException(status_code=500, detail=f"Failed to enroll in course: {str(e)}")
+        
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Error enrolling in course: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error enrolling in course: {str(e)}")
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+# Get enrolled courses for the current user
+@router.get("/user/courses", response_model=List[Course])
+async def get_enrolled_courses(
+    request: Request,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+        
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            
+            # Get LearnerID from Learners table using the username
+            conn = connect_db()
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                cursor.execute("""
+                    SELECT LearnerID 
+                    FROM Learners 
+                    WHERE AccountName = %s
+                """, (user_data['username'],))
+                learner = cursor.fetchone()
+                if not learner:
+                    raise HTTPException(status_code=404, detail="Learner not found")
+                learner_id = learner['LearnerID']
+        except Exception as e:
+            print(f"Token/user verification error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token or user not found")
+
+        # Get enrolled courses
+        courses = []
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            query = """
+                SELECT 
+                    c.CourseID as id, 
+                    c.CourseName as name, 
+                    CONCAT(i.InstructorName, ' (', i.AccountName, ')') as instructor,
+                    c.Descriptions as description
+                FROM Courses c
+                JOIN Instructors i ON c.InstructorID = i.InstructorID
+                JOIN Enrollments e ON c.CourseID = e.CourseID
+                WHERE e.LearnerID = %s
+            """
+            cursor.execute(query, (learner_id,))
+            courses = cursor.fetchall()
+            
+            # Get ratings and enrollment count for each course
+            for course in courses:
+                cursor.execute("""
+                    SELECT AVG(Rating) as avg_rating, COUNT(*) as count
+                    FROM Enrollments
+                    WHERE CourseID = %s AND Rating IS NOT NULL
+                """, (course['id'],))
+                
+                rating_data = cursor.fetchone()
+                if rating_data and rating_data['avg_rating']:
+                    course['rating'] = float(rating_data['avg_rating'])
+                else:
+                    course['rating'] = None
+                    
+                # Get enrollment count
+                cursor.execute("""
+                    SELECT COUNT(*) as enrolled
+                    FROM Enrollments
+                    WHERE CourseID = %s
+                """, (course['id'],))
+                
+                enrolled_data = cursor.fetchone()
+                if enrolled_data:
+                    course['enrolled'] = enrolled_data['enrolled']
+                else:
+                    course['enrolled'] = 0
+        
+        return courses
+        
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Error fetching enrolled courses: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error fetching enrolled courses: {str(e)}")
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+# Get user profile
+@router.get("/user/profile")
+async def get_user_profile(
+    request: Request,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+        
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            username = user_data['username']
+            role = user_data['role']
+            
+            # Connect to database
+            conn = connect_db()
+            
+            # Get user information based on role
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                if role == "Learner":
+                    cursor.execute("""
+                        SELECT 
+                            LearnerName as name,
+                            Email as email,
+                            PhoneNumber as phoneNumber
+                        FROM Learners
+                        WHERE AccountName = %s
+                    """, (username,))
+                    user_info = cursor.fetchone()
+                    
+                    if not user_info:
+                        raise HTTPException(status_code=404, detail="Learner not found")
+                        
+                elif role == "Instructor":
+                    cursor.execute("""
+                        SELECT 
+                            InstructorName as name,
+                            Email as email,
+                            Expertise as expertise
+                        FROM Instructors
+                        WHERE AccountName = %s
+                    """, (username,))
+                    user_info = cursor.fetchone()
+                    
+                    if not user_info:
+                        raise HTTPException(status_code=404, detail="Instructor not found")
+                else:
+                    raise HTTPException(status_code=403, detail="Invalid user role")
+                
+                # Add role and username to the response
+                user_info['role'] = role
+                user_info['username'] = username
+                
+                return user_info
+                
+        except Exception as e:
+            print(f"Token/user verification error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token or user not found")
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Error fetching user profile: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error fetching user profile: {str(e)}")
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+# Update user profile
+@router.put("/user/profile")
+async def update_user_profile(
+    request: Request,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+        
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            username = user_data['username']
+            role = user_data['role']
+            
+            # Get request body
+            profile_data = await request.json()
+            
+            # Connect to database
+            conn = connect_db()
+            
+            # Update user information based on role
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                if role == "Learner":
+                    # Prepare update fields
+                    update_fields = []
+                    params = []
+                    
+                    if 'name' in profile_data:
+                        update_fields.append("LearnerName = %s")
+                        params.append(profile_data['name'])
+                    
+                    if 'email' in profile_data:
+                        update_fields.append("Email = %s")
+                        params.append(profile_data['email'])
+                    
+                    if 'phoneNumber' in profile_data:
+                        update_fields.append("PhoneNumber = %s")
+                        params.append(profile_data['phoneNumber'])
+                    
+                    if not update_fields:
+                        return {"message": "No fields to update"}
+                    
+                    # Add username to params
+                    params.append(username)
+                    
+                    # Construct and execute SQL
+                    sql = f"""
+                        UPDATE Learners
+                        SET {', '.join(update_fields)}
+                        WHERE AccountName = %s
+                    """
+                    cursor.execute(sql, params)
+                    
+                elif role == "Instructor":
+                    # Prepare update fields
+                    update_fields = []
+                    params = []
+                    
+                    if 'name' in profile_data:
+                        update_fields.append("InstructorName = %s")
+                        params.append(profile_data['name'])
+                    
+                    if 'email' in profile_data:
+                        update_fields.append("Email = %s")
+                        params.append(profile_data['email'])
+                    
+                    if 'expertise' in profile_data:
+                        update_fields.append("Expertise = %s")
+                        params.append(profile_data['expertise'])
+                    
+                    if not update_fields:
+                        return {"message": "No fields to update"}
+                    
+                    # Add username to params
+                    params.append(username)
+                    
+                    # Construct and execute SQL
+                    sql = f"""
+                        UPDATE Instructors
+                        SET {', '.join(update_fields)}
+                        WHERE AccountName = %s
+                    """
+                    cursor.execute(sql, params)
+                    
+                else:
+                    raise HTTPException(status_code=403, detail="Invalid user role")
+                
+                conn.commit()
+                return {"message": "Profile updated successfully"}
+                
+        except Exception as e:
+            print(f"Token/user verification error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token or user not found")
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Error updating user profile: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error updating user profile: {str(e)}")
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+# Get dashboard data for the current user
+@router.get("/user/dashboard")
+async def get_user_dashboard(
+    request: Request,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+        
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            
+            # Get LearnerID from Learners table using the username
+            conn = connect_db()
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                cursor.execute("""
+                    SELECT LearnerID, LearnerName 
+                    FROM Learners 
+                    WHERE AccountName = %s
+                """, (user_data['username'],))
+                learner = cursor.fetchone()
+                if not learner:
+                    raise HTTPException(status_code=404, detail="Learner not found")
+                learner_id = learner['LearnerID']
+                learner_name = learner['LearnerName']
+        except Exception as e:
+            print(f"Token/user verification error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token or user not found")
+
+        # Calculate dashboard metrics
+        dashboard_data = {
+            "learnerName": learner_name,
+            "enrolled": 0,
+            "completed": 0,
+            "completionRate": "0%",
+            "lecturesPassed": 0,
+            "statistics": {
+                "lecturesPassed": [],
+                "averageScores": []
+            },
+            "enrolledCourses": []
+        }
+        
+        with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+            # Get enrollment count
+            cursor.execute("SELECT COUNT(*) as count FROM Enrollments WHERE LearnerID = %s", (learner_id,))
+            enrolled_data = cursor.fetchone()
+            dashboard_data["enrolled"] = enrolled_data['count'] if enrolled_data else 0
+            
+            # Get completed courses count
+            cursor.execute(
+                "SELECT COUNT(*) as count FROM Enrollments WHERE LearnerID = %s AND Percentage = 100",
+                (learner_id,)
+            )
+            completed_data = cursor.fetchone()
+            completed = completed_data['count'] if completed_data else 0
+            dashboard_data["completed"] = completed
+            
+            # Calculate completion rate
+            if dashboard_data["enrolled"] > 0:
+                rate = (completed / dashboard_data["enrolled"]) * 100
+                dashboard_data["completionRate"] = f"{rate:.1f}%"
+            
+            # Get passed lectures count
+            cursor.execute(
+                "SELECT COUNT(*) as count FROM LectureResults WHERE LearnerID = %s AND State = 'passed'",
+                (learner_id,)
+            )
+            passed_data = cursor.fetchone()
+            dashboard_data["lecturesPassed"] = passed_data['count'] if passed_data else 0
+            
+            # Get statistics data - passed lectures over time
+            cursor.execute("""
+                SELECT Date, Score, 
+                        DATE_FORMAT(Date, '%%Y-%%m-%%d') as formatted_date
+                FROM LectureResults
+                WHERE LearnerID = %s AND State = 'passed'
+                ORDER BY Date
+            """, (learner_id,))
+            
+            stats_data = cursor.fetchall()
+            date_groups = {}
+            score_groups = {}
+            
+            for row in stats_data:
+                date_str = row['formatted_date']
+                if date_str not in date_groups:
+                    date_groups[date_str] = 0
+                date_groups[date_str] += 1
+                
+                if date_str not in score_groups:
+                    score_groups[date_str] = {"total": 0, "count": 0}
+                score_groups[date_str]["total"] += row['Score']
+                score_groups[date_str]["count"] += 1
+            
+            # Format the statistics data
+            for date_str in date_groups:
+                dashboard_data["statistics"]["lecturesPassed"].append({
+                    "date": date_str,
+                    "count": date_groups[date_str]
+                })
+                
+                avg_score = score_groups[date_str]["total"] / score_groups[date_str]["count"]
+                dashboard_data["statistics"]["averageScores"].append({
+                    "date": date_str,
+                    "score": round(avg_score, 2)
+                })
+            
+            # Get enrolled courses with percentage
+            cursor.execute("""
+                SELECT
+                    c.CourseID as id, 
+                    c.CourseName as name, 
+                    CONCAT(i.InstructorName, ' (', i.AccountName, ')') as instructor,
+                    c.Descriptions as description,
+                    e.Percentage as percentage
+                FROM Courses c
+                JOIN Instructors i ON c.InstructorID = i.InstructorID
+                JOIN Enrollments e ON c.CourseID = e.CourseID
+                WHERE e.LearnerID = %s
+            """, (learner_id,))
+            
+            courses = cursor.fetchall()
+            dashboard_data["enrolledCourses"] = courses
+            
+        return dashboard_data
+        
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Error fetching dashboard data: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error fetching dashboard data: {str(e)}")
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+# Get dashboard data for instructor
+@router.get("/instructor/dashboard")
+async def get_instructor_dashboard(
+    request: Request,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+        
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            username = user_data.get('username')
+            role = user_data.get('role')
+            
+            if not username or not role:
+                raise HTTPException(status_code=401, detail="Invalid token data")
+            
+            # Verify user is an instructor
+            if role != "Instructor":
+                raise HTTPException(status_code=403, detail="Only instructors can access this endpoint")
+            
+            # Connect to database
+            conn = connect_db()
+            
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                # Get instructor ID
+                try:
+                    cursor.execute("""
+                        SELECT InstructorID 
+                        FROM Instructors 
+                        WHERE AccountName = %s
+                    """, (username,))
+                    
+                    instructor = cursor.fetchone()
+                    if not instructor:
+                        raise HTTPException(status_code=404, detail="Instructor not found")
+                    
+                    instructor_id = instructor['InstructorID']
+                except Exception as e:
+                    print(f"Error getting instructor ID: {str(e)}")
+                    raise HTTPException(status_code=500, detail="Error retrieving instructor information")
+                
+                try:
+                    # Get total courses
+                    cursor.execute("""
+                        SELECT COUNT(*) as total_courses
+                        FROM Courses
+                        WHERE InstructorID = %s
+                    """, (instructor_id,))
+                    total_courses = cursor.fetchone()['total_courses']
+                    
+                    # Get total students and stats
+                    cursor.execute("""
+                        SELECT 
+                            COUNT(DISTINCT e.LearnerID) as total_students,
+                            COALESCE(AVG(e.Rating), 0) as average_rating,
+                            COUNT(*) as total_enrollments,
+                            SUM(CASE WHEN e.Percentage = 100 THEN 1 ELSE 0 END) as completed_enrollments
+                        FROM Courses c
+                        LEFT JOIN Enrollments e ON c.CourseID = e.CourseID
+                        WHERE c.InstructorID = %s
+                    """, (instructor_id,))
+                    
+                    stats = cursor.fetchone()
+                    if not stats:
+                        stats = {
+                            'total_students': 0,
+                            'average_rating': 0,
+                            'total_enrollments': 0,
+                            'completed_enrollments': 0
+                        }
+                    
+                    completion_rate = round((stats['completed_enrollments'] / stats['total_enrollments'] * 100)
+                                         if stats['total_enrollments'] > 0 else 0, 1)
+                    
+                    # Get student growth
+                    cursor.execute("""
+                        SELECT 
+                            DATE_FORMAT(EnrollmentDate, '%%Y-%%m') as month,
+                            COUNT(DISTINCT LearnerID) as students
+                        FROM Courses c
+                        JOIN Enrollments e ON c.CourseID = e.CourseID
+                        WHERE c.InstructorID = %s
+                        AND EnrollmentDate >= DATE_SUB(CURRENT_DATE, INTERVAL 2 MONTH)
+                        GROUP BY DATE_FORMAT(EnrollmentDate, '%%Y-%%m')
+                        ORDER BY month DESC
+                        LIMIT 2
+                    """, (instructor_id,))
+                    
+                    growth_data = cursor.fetchall()
+                    
+                    current_month = growth_data[0]['students'] if growth_data else 0
+                    prev_month = growth_data[1]['students'] if len(growth_data) > 1 else 0
+                    student_growth = round(((current_month - prev_month) / prev_month * 100)
+                                        if prev_month > 0 else 0, 1)
+                    
+                    # Get courses
+                    cursor.execute("""
+                        SELECT 
+                            c.CourseID as id,
+                            c.CourseName as name,
+                            c.Descriptions as description,
+                            c.AverageRating as rating,
+                            COUNT(DISTINCT e.LearnerID) as enrollments,
+                            AVG(e.Percentage) as completionRate
+                        FROM Courses c
+                        LEFT JOIN Enrollments e ON c.CourseID = e.CourseID
+                        WHERE c.InstructorID = %s
+                        GROUP BY c.CourseID, c.CourseName, c.Descriptions, c.AverageRating
+                        ORDER BY c.CreatedAt DESC
+                    """, (instructor_id,))
+                    
+                    courses = cursor.fetchall() or []
+                    
+                    # Get enrollment trends
+                    cursor.execute("""
+                        SELECT 
+                            DATE_FORMAT(e.EnrollmentDate, '%%Y-%%m-%%d') as date,
+                            COUNT(*) as value
+                        FROM Courses c
+                        JOIN Enrollments e ON c.CourseID = e.CourseID
+                        WHERE c.InstructorID = %s
+                        AND e.EnrollmentDate >= DATE_SUB(CURRENT_DATE, INTERVAL 30 DAY)
+                        GROUP BY DATE_FORMAT(e.EnrollmentDate, '%%Y-%%m-%%d')
+                        ORDER BY date
+                    """, (instructor_id,))
+                    
+                    enrollment_trends = cursor.fetchall() or []
+                    
+                    # Get rating trends
+                    cursor.execute("""
+                        SELECT 
+                            DATE_FORMAT(e.EnrollmentDate, '%%Y-%%m-%%d') as date,
+                            AVG(e.Rating) as value
+                        FROM Courses c
+                        JOIN Enrollments e ON c.CourseID = e.CourseID
+                        WHERE c.InstructorID = %s
+                        AND e.EnrollmentDate >= DATE_SUB(CURRENT_DATE, INTERVAL 30 DAY)
+                        AND e.Rating IS NOT NULL
+                        GROUP BY DATE_FORMAT(e.EnrollmentDate, '%%Y-%%m-%%d')
+                        ORDER BY date
+                    """, (instructor_id,))
+                    
+                    rating_trends = cursor.fetchall() or []
+                    
+                    # Format the data
+                    formatted_courses = [
+                        {
+                            'id': course['id'],
+                            'name': course['name'],
+                            'description': course['description'] or "",
+                            'enrollments': course['enrollments'] or 0,
+                            'rating': round(float(course['rating']), 1) if course['rating'] else 0.0,
+                            'completionRate': round(float(course['completionRate']), 1) if course['completionRate'] else 0.0
+                        } for course in courses
+                    ]
+                    
+                    formatted_enrollment_trends = [
+                        {
+                            'date': trend['date'],
+                            'value': int(trend['value'])
+                        } for trend in enrollment_trends
+                    ]
+                    
+                    formatted_rating_trends = [
+                        {
+                            'date': trend['date'],
+                            'value': round(float(trend['value']), 1)
+                        } for trend in rating_trends if trend['value'] is not None
+                    ]
+                    
+                    dashboard_data = {
+                        "metrics": {
+                            "totalCourses": total_courses,
+                            "totalStudents": stats['total_students'],
+                            "averageRating": round(float(stats['average_rating']), 1),
+                            "completionRate": completion_rate,
+                            "studentGrowth": student_growth
+                        },
+                        "courses": formatted_courses,
+                        "enrollmentTrends": formatted_enrollment_trends,
+                        "ratingTrends": formatted_rating_trends,
+                        "courseEnrollments": [
+                            {
+                                "courseName": course['name'],
+                                "enrollments": course['enrollments'] or 0
+                            } for course in courses
+                        ]
+                    }
+                    
+                    return dashboard_data
+                    
+                except Exception as e:
+                    print(f"Error processing dashboard data: {str(e)}")
+                    raise HTTPException(status_code=500, detail="Error processing dashboard data")
+                
+        except HTTPException as he:
+            raise he
+        except Exception as e:
+            print(f"Database error: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+            
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Error fetching instructor dashboard: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+# Quiz submission model
+class QuizSubmission(BaseModel):
+    answers: dict[int, str]  # questionId -> selected answer text
+
+@router.post("/lectures/{lecture_id}/quiz/submit")
+async def submit_quiz_answers(
+    lecture_id: int,
+    submission: QuizSubmission,
+    request: Request,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            # Get LearnerID from Learners table using the username
+            conn = connect_db()
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                cursor.execute("""
+                    SELECT LearnerID 
+                    FROM Learners 
+                    WHERE AccountName = %s
+                """, (user_data['username'],))
+                learner = cursor.fetchone()
+                if not learner:
+                    raise HTTPException(status_code=404, detail="Learner not found")
+                learner_id = learner['LearnerID']
+        except Exception as e:
+            print(f"Token/user verification error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token or user not found")
+
+        try:
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                # First verify the quiz exists for this lecture
+                cursor.execute("""
+                    SELECT QuizID 
+                    FROM Quizzes 
+                    WHERE LectureID = %s
+                """, (lecture_id,))
+                quiz = cursor.fetchone()
+                if not quiz:
+                    raise HTTPException(status_code=404, detail="Quiz not found for this lecture")
+
+                quiz_id = quiz['QuizID']
+
+                # Get correct answers for validation
+                cursor.execute("""
+                    SELECT q.QuestionID, o.OptionText
+                    FROM Questions q
+                    JOIN Options o ON q.QuestionID = o.QuestionID
+                    WHERE q.QuizID = %s AND o.IsCorrect = 1
+                """, (quiz_id,))
+                
+                correct_answers = {row['QuestionID']: row['OptionText'] for row in cursor.fetchall()}
+                
+                # Calculate score
+                total_questions = len(correct_answers)
+                if total_questions == 0:
+                    raise HTTPException(status_code=500, detail="No questions found for this quiz")
+
+                correct_count = sum(
+                    1 for q_id, answer in submission.answers.items()
+                    if str(q_id) in map(str, correct_answers.keys()) and answer == correct_answers[int(q_id)]
+                )
+                
+                score = (correct_count / total_questions) * 100
+
+                # Get the CourseID for this lecture
+                cursor.execute("""
+                    SELECT CourseID
+                    FROM Lectures
+                    WHERE LectureID = %s
+                """, (lecture_id,))
+                lecture_data = cursor.fetchone()
+                if not lecture_data:
+                    raise HTTPException(status_code=404, detail="Lecture not found")
+                
+                course_id = lecture_data['CourseID']
+
+                # Save or update the score using direct SQL instead of stored procedure
+                try:
+                    # Use stored procedure to update or insert the lecture result
+                    cursor.execute(
+                        "CALL sp_update_lecture_result(%s, %s, %s, %s)",
+                        (learner_id, course_id, lecture_id, score)
+                    )
+                    
+                    # Update course completion percentage
+                    try:
+                        # Get total lectures in the course
+                        cursor.execute("""
+                            SELECT COUNT(*) as total_lectures 
+                            FROM Lectures 
+                            WHERE CourseID = %s
+                        """, (course_id,))
+                        total_lectures = cursor.fetchone()['total_lectures']
+                        
+                        # Get passed lectures
+                        cursor.execute("""
+                            SELECT COUNT(*) as passed_lectures 
+                            FROM LectureResults 
+                            WHERE LearnerID = %s AND CourseID = %s AND State = 'passed'
+                        """, (learner_id, course_id))
+                        passed_lectures = cursor.fetchone()['passed_lectures']
+                        
+                        # Calculate percentage
+                        if total_lectures > 0:
+                            percentage_raw = (passed_lectures * 100.0) / total_lectures
+                            
+                            # Convert to percentage scale
+                            if percentage_raw < 10:
+                                percentage = 0
+                            elif percentage_raw < 30:
+                                percentage = 20
+                            elif percentage_raw < 50:
+                                percentage = 40
+                            elif percentage_raw < 70:
+                                percentage = 60
+                            elif percentage_raw < 90:
+                                percentage = 80
+                            else:
+                                percentage = 100
+                                
+                            # Update enrollment record
+                            cursor.execute("""
+                                UPDATE Enrollments
+                                SET Percentage = %s
+                                WHERE LearnerID = %s AND CourseID = %s
+                            """, (percentage, learner_id, course_id))
+                    except Exception as e:
+                        print(f"Error updating course percentage: {str(e)}")
+                        # Continue even if percentage update fails
+                    
+                    conn.commit()
+                    print(f"Score updated successfully for learner {learner_id}, lecture {lecture_id}")
+                except Exception as e:
+                    print(f"Error saving quiz score: {str(e)}")
+                    conn.rollback()
+                    raise HTTPException(status_code=500, detail=f"Failed to save quiz score: {str(e)}")
+
+                return {
+                    "score": score,
+                    "total_questions": total_questions,
+                    "correct_answers": correct_count
+                }
+
+        finally:
+            conn.close()
+
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Error submitting quiz: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error submitting quiz: {str(e)}")
+
+@router.get("/lectures/{lecture_id}/quiz/results")
+async def get_quiz_results(
+    lecture_id: int,
+    request: Request,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Verify auth token
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+        
+        if not auth_token:
+            raise HTTPException(status_code=401, detail="No authentication token provided")
+            
+        try:
+            user_data = decode_token(auth_token)
+        except Exception as e:
+            print(f"Token decode error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token")
+
+        conn = connect_db()
+        try:
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                cursor.execute("""
+                    SELECT Score, State, Date
+                    FROM LectureResults
+                    WHERE LearnerID = %s AND LectureID = %s
+                    ORDER BY Date DESC
+                    LIMIT 1
+                """, (user_data["id"], lecture_id))
+                
+                result = cursor.fetchone()
+                if not result:
+                    return None
+                    
+                return {
+                    "score": float(result["Score"]),
+                    "status": result["State"],
+                    "date": result["Date"].isoformat()
+                }
+                
+        finally:
+            conn.close()
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Error in get_quiz_results: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Test endpoints for debugging route registration
+@router.get("/instructor/courses/test")
+async def test_instructor_courses_get():
+    return {"message": "GET /instructor/courses/test works"}
+
+@router.post("/instructor/courses/test")
+async def test_instructor_courses_post():
+    return {"message": "POST /instructor/courses/test works"}
+
+# Get instructor course details
+@router.get("/instructor/courses/{course_id}", response_model=Course)
+async def get_instructor_course_details(
+    request: Request,
+    course_id: int,
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+        
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            username = user_data['username']
+            role = user_data['role']
+            
+            # Verify user is an instructor
+            if role != "Instructor":
+                raise HTTPException(status_code=403, detail="Only instructors can access this endpoint")
+            
+            # Connect to database
+            conn = connect_db()
+            
+            with conn.cursor(pymysql.cursors.DictCursor) as cursor:
+                # Get instructor ID
+                cursor.execute("""
+                    SELECT InstructorID 
+                    FROM Instructors 
+                    WHERE AccountName = %s
+                """, (username,))
+                
+                instructor = cursor.fetchone()
+                if not instructor:
+                    raise HTTPException(status_code=404, detail="Instructor not found")
+                
+                instructor_id = instructor['InstructorID']
+                
+                # Get course details, ensuring it belongs to this instructor
+                query = """
+                    SELECT 
+                        c.CourseID as id, 
+                        c.CourseName as name, 
+                        CONCAT(i.InstructorName, ' (', i.AccountName, ')') as instructor,
+                        c.Descriptions as description,
+                        (SELECT COUNT(*) FROM Enrollments WHERE CourseID = c.CourseID) as enrolled,
+                        COALESCE(
+                            (SELECT AVG(Rating) 
+                             FROM Enrollments 
+                             WHERE CourseID = c.CourseID AND Rating IS NOT NULL),
+                            0
+                        ) as rating,
+                        c.Skills as skills,
+                        c.Difficulty as difficulty,
+                        c.EstimatedDuration as duration
+                    FROM Courses c
+                    JOIN Instructors i ON c.InstructorID = i.InstructorID
+                    WHERE c.CourseID = %s AND c.InstructorID = %s
+                """
+                
+                cursor.execute(query, (course_id, instructor_id))
+                course = cursor.fetchone()
+                
+                if not course:
+                    raise HTTPException(status_code=404, detail=f"Course with ID {course_id} not found or not owned by this instructor")
+                
+                # Format the course data
+                if course['rating']:
+                    course['rating'] = float(course['rating'])
+                
+                # Convert skills from JSON string if needed
+                if isinstance(course.get('skills'), str):
+                    try:
+                        course['skills'] = json.loads(course['skills'])
+                    except:
+                        course['skills'] = []
+                
+                return course
+                
+        except Exception as e:
+            print(f"Database error: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
+            
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Error fetching instructor course details: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if 'conn' in locals():
+            conn.close()
+
+# CreateLecture model and create_lecture endpoint to handle lecture creation with video upload and quiz
+class CreateLecture(BaseModel):
+    title: str
+    description: str
+    content: str
+    quiz: Optional[dict] = None
+
+@router.post("/courses/{course_id}/lectures")
+async def create_lecture(
+    request: Request,
+    course_id: int,
+    auth_token: str = Cookie(None),
+    title: str = Form(...),
+    description: str = Form(...),
+    content: str = Form(...),
+    video: Optional[UploadFile] = File(None),
+    quiz: Optional[str] = Form(None)
+):
+    try:
+        # Get token from header if not in cookie
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+            else:
+                raise HTTPException(status_code=401, detail="No authentication token provided")
+        
+        # Verify token and get user data
+        try:
+            user_data = decode_token(auth_token)
+            username = user_data['username']
+            role = user_data['role']
+            
+            # Verify user is an instructor
+            if role != "Instructor":
+                raise HTTPException(status_code=403, detail="Only instructors can access this endpoint")
+            
+            # Connect to database
+            conn = connect_db()
+            cursor = conn.cursor(pymysql.cursors.DictCursor)
+            
+            try:
+                # Get instructor ID
+                cursor.execute("""
+                    SELECT InstructorID 
+                    FROM Instructors 
+                    WHERE AccountName = %s
+                """, (username,))
+                
+                instructor = cursor.fetchone()
+                if not instructor:
+                    raise HTTPException(status_code=404, detail="Instructor not found")
+                
+                instructor_id = instructor['InstructorID']
+                
+                # Verify this instructor owns this course
+                cursor.execute("""
+                    SELECT CourseID 
+                    FROM Courses 
+                    WHERE CourseID = %s AND InstructorID = %s
+                """, (course_id, instructor_id))
+                
+                if not cursor.fetchone():
+                    raise HTTPException(status_code=403, detail="Not authorized to modify this course")
+                
+                # Create the lecture
+                cursor.execute("""
+                    INSERT INTO Lectures (CourseID, Title, Description, Content) 
+                    VALUES (%s, %s, %s, %s)
+                """, (course_id, title, description, content))
+                conn.commit()
+                
+                # Get the newly created lecture ID
+                lecture_id = cursor.lastrowid
+                
+                # Upload video if provided
+                if video:
+                    # Check file size (100MB limit)
+                    video_content = await video.read()
+                    if len(video_content) > 100 * 1024 * 1024:  # 100MB in bytes
+                        raise HTTPException(status_code=400, detail="Video file size must be less than 100MB")
+                    
+                    # Check file type
+                    if not video.content_type.startswith('video/'):
+                        raise HTTPException(status_code=400, detail="Invalid file type. Please upload a video file")
+                    
+                    # Upload to S3
+                    media_path = f"videos/cid{course_id}/lid{lecture_id}/vid_lecture.mp4"
+                    s3.put_object(
+                        Bucket="tlhmaterials",
+                        Key=media_path,
+                        Body=video_content,
+                        ContentType=video.content_type,
+                        ACL="public-read",
+                        ContentDisposition="inline"
+                    )
+                
+                # Create quiz if provided
+                if quiz:
+                    quiz_data = json.loads(quiz)
+                    if quiz_data and quiz_data.get('questions'):
+                        # Insert quiz
+                        cursor.execute("""
+                            INSERT INTO Quizzes (LectureID, Title, Description) 
+                            VALUES (%s, %s, %s)
+                        """, (lecture_id, f"Quiz for {title}", description))
+                        conn.commit()
+                        
+                        quiz_id = cursor.lastrowid
+                        
+                        # Insert questions and options
+                        for question in quiz_data['questions']:
+                            cursor.execute("""
+                                INSERT INTO Questions (QuizID, QuestionText) 
+                                VALUES (%s, %s)
+                            """, (quiz_id, question['question']))
+                            conn.commit()
+                            
+                            question_id = cursor.lastrowid
+                            
+                            # Insert options
+                            for i, option in enumerate(question['options']):
+                                cursor.execute("""
+                                    INSERT INTO Options (QuestionID, OptionText, IsCorrect)
+                                    VALUES (%s, %s, %s)
+                                """, (question_id, option, i == question['correctAnswer']))
+                            conn.commit()
+                
+                return {
+                    "id": lecture_id,
+                    "title": title,
+                    "message": "Lecture created successfully"
+                }
+                
+            except HTTPException:
+                raise
+            except Exception as e:
+                print(f"Error in create_lecture: {str(e)}")
+                raise HTTPException(status_code=500, detail=f"Failed to create lecture: {str(e)}")
+            
+        except Exception as e:
+            print(f"Token/user verification error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token or user not found")
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Error in create_lecture: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if 'conn' in locals():
+            conn.close()

services/api/chat_endpoints.py

@@ -0,0 +1,102 @@
+from fastapi import APIRouter, Depends, HTTPException, Request, Cookie
+from typing import Dict
+from services.api.db.token_utils import decode_token
+from services.api.chatbot.core import get_chat_response, get_chat_response_lecture
+from pydantic import BaseModel
+
+router = APIRouter()
+
+class ChatMessage(BaseModel):
+    message: str
+
+@router.post("/chat")
+async def chat_endpoint(message: ChatMessage, request: Request, auth_token: str = Cookie(None)):
+    try:
+        # Verify auth token
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+        
+        if not auth_token:
+            raise HTTPException(status_code=401, detail="No authentication token provided")
+            
+        try:
+            user_data = decode_token(auth_token)
+        except Exception as e:
+            print(f"Token decode error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token")
+        
+        # Get chatbot response
+        response = get_chat_response(message.message)
+        return {"answer": response}
+
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Chat error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/chat/lecture/{lecture_id}")
+async def lecture_chat_endpoint(
+    lecture_id: int, 
+    message: ChatMessage, 
+    request: Request, 
+    auth_token: str = Cookie(None)
+):
+    try:
+        # Verify auth token
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+        
+        if not auth_token:
+            raise HTTPException(status_code=401, detail="No authentication token provided")
+            
+        try:
+            user_data = decode_token(auth_token)
+        except Exception as e:
+            print(f"Token decode error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token")
+        
+        # Get chatbot response for specific lecture
+        response = get_chat_response_lecture(message.message, lecture_id)
+        return {"answer": response}
+
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Lecture chat error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/chat/history")
+async def clear_history_endpoint(request: Request, auth_token: str = Cookie(None)):
+    try:
+        # Verify auth token
+        if not auth_token:
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                auth_token = auth_header.split(' ')[1]
+        
+        if not auth_token:
+            raise HTTPException(status_code=401, detail="No authentication token provided")
+            
+        try:
+            user_data = decode_token(auth_token)
+        except Exception as e:
+            print(f"Token decode error: {str(e)}")
+            raise HTTPException(status_code=401, detail="Invalid authentication token")
+        
+        # Clear both regular and lecture chat history
+        from services.api.chatbot.core import clear_chat_history, clear_lecture_chat_history
+        clear_chat_history()
+        clear_lecture_chat_history()
+        
+        return {"status": "success", "message": "Chat history cleared"}
+
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        print(f"Clear history error: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))

services/api/chatbot/config.py

@@ -0,0 +1,18 @@
+import google.generativeai as genai
+from langchain.llms.base import LLM
+from typing import List, Optional
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+QDRANT_HOST = os.getenv("QDRANT_HOST")
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+
+QDRANT_COLLECTION_NAME = "dbms_collection_courses"
+QDRANT_COLLECTION_NAME_LECTURES = "dbms_collection_lectures"
+MODEL_NAME = "gemini-2.0-flash"
+
+EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+EMBEDDING_SIZE = 384

services/api/chatbot/core.py

@@ -0,0 +1,117 @@
+from .llm import gemini_llm
+from langchain.chains import ConversationalRetrievalChain
+from langchain.memory import ConversationBufferMemory
+from .retrieval import get_vectorstore, sync_courses_to_qdrant, get_vectorstore_lectures
+from langchain.chains import RetrievalQA
+from .prompts import courses_prompt, condense_prompt, lectures_prompt
+from qdrant_client.http import models
+
+
+import qdrant_client
+from .config import (
+    EMBEDDING_MODEL,
+    QDRANT_HOST,
+    QDRANT_API_KEY,
+    QDRANT_COLLECTION_NAME,
+    EMBEDDING_SIZE,
+    QDRANT_COLLECTION_NAME_LECTURES,
+)
+# from langchain.retrievers.self_query.base import SelfQueryRetriever
+# from langchain.retrievers.self_query.qdrant import QdrantTranslator
+client = qdrant_client.QdrantClient(QDRANT_HOST, api_key=QDRANT_API_KEY)
+
+vector_store = get_vectorstore()
+vector_store_lecture = get_vectorstore_lectures()
+memory = ConversationBufferMemory(
+    memory_key="chat_history",
+    return_messages=True,
+    output_key="answer"
+)
+
+memory_lecture = ConversationBufferMemory(
+    memory_key="chat_history",
+    return_messages=True,
+    output_key="answer"
+)
+
+qa_chain = ConversationalRetrievalChain.from_llm(
+    llm=gemini_llm,
+    retriever=vector_store.as_retriever(search_kwargs={"k": 5}),
+    memory=memory,
+    condense_question_prompt=condense_prompt,  
+    combine_docs_chain_kwargs={
+        "prompt": courses_prompt  
+    },
+    return_source_documents=True
+)
+
+def bulid_qa_chain(lecture_id: int):
+    return ConversationalRetrievalChain.from_llm(
+        llm=gemini_llm,
+        retriever = vector_store_lecture.as_retriever(
+        search_kwargs={
+            "k": 5,
+            "filter": models.Filter(
+                must=[
+                    models.FieldCondition(
+                        key="metadata.LectureID",
+                        match=models.MatchValue(value=lecture_id),
+                    )
+                ]
+            )
+        }
+    ),
+        memory=memory_lecture,
+        condense_question_prompt=condense_prompt,  
+        combine_docs_chain_kwargs={
+            "prompt": lectures_prompt
+        },
+        return_source_documents=True
+    )
+
+def get_chat_response_lecture(user_input: str, lecture_id: int) -> str:
+    print(f"\n[DEBUG] Sample points from Qdrant for LectureID={lecture_id}")
+    points, _ = client.scroll(
+        collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+        limit=10,
+        with_payload=True,
+        with_vectors=False,
+        scroll_filter=models.Filter(
+            must=[
+                models.FieldCondition(
+                    key="metadata.LectureID",
+                    match=models.MatchValue(value=lecture_id)
+                )
+            ]
+        )
+    )
+    print(points[0].payload)
+    qa_chain_lecture = bulid_qa_chain(lecture_id)
+    response = qa_chain_lecture({"question": user_input})
+    print(lecture_id)
+    print()
+    print("Source Documents:")
+    for i, doc in enumerate(response["source_documents"], start=1):
+        cid = doc.metadata.get("LectureID", "N/A")
+        content = doc.page_content
+        print(f"{i}. CourseID={cid}\n   {content}\n")
+    return response["answer"]
+
+def get_chat_response(user_input: str) -> str:
+    response = qa_chain({"question": user_input})
+    print("Source Documents:")
+    for i, doc in enumerate(response["source_documents"], start=1):
+        cid = doc.metadata.get("CourseID", "N/A")
+        content = doc.page_content
+        print(f"{i}. CourseID={cid}\n   {content}\n")
+    return response["answer"]
+
+def clear_chat_history():
+    """Clear the conversation memory for general chat"""
+    memory.clear()
+    return {"status": "success", "message": "Chat history cleared"}
+
+def clear_lecture_chat_history():
+    """Clear the conversation memory for lecture-specific chat"""
+    memory_lecture.clear()
+    return {"status": "success", "message": "Lecture chat history cleared"}

services/api/chatbot/llm.py

@@ -0,0 +1,29 @@
+import google.generativeai as genai
+from langchain.llms.base import LLM
+from typing import Optional, List
+from .config import GEMINI_API_KEY, MODEL_NAME
+
+genai.configure(api_key=GEMINI_API_KEY)
+
+class GeminiWrapper(LLM):
+    """Wrapper để sử dụng Gemini với LangChain."""
+    
+    model: str = MODEL_NAME
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+        """Gửi prompt đến Gemini và trả về kết quả."""
+        model = genai.GenerativeModel(self.model)
+        response = model.generate_content(prompt)
+        return response.text if response and hasattr(response, 'text') else "Không có phản hồi từ Gemini."
+
+    @property
+    def _identifying_params(self) -> dict:
+        """Trả về tham số nhận diện của mô hình."""
+        return {"model": self.model}
+    
+    @property
+    def _llm_type(self) -> str:
+        return "gemini"
+
+gemini_llm = GeminiWrapper()
+

services/api/chatbot/prompts.py

@@ -0,0 +1,73 @@
+from langchain.prompts import PromptTemplate
+# from .llm import gemini_llm
+# from langchain_core.prompts import ChatPromptTemplate
+
+courses_prompt = PromptTemplate(
+    input_variables=["context", "question"],
+    template="""
+Your name is Edumate. You are an AI assistant of THE LEARNING HOUSE — an online learning platform that provides a wide variety of courses.
+
+Your mission is to help users find courses that match their needs and answer any additional questions they might have.
+
+If users didn't show their demand to learning(e.g: They gretting, introduce, ...) introduce about yourself, that you're here to help them find most suitable course.
+If enough information that show their preference, lets priotize recommend user with suitable course
+
+Below is a list of courses retrieved from our database. Recommend relevant courses to the user by providing helpful information about each course.
+{context}
+If none of the available courses match the user's demand, politely inform them that we currently do not have a suitable course and that their request has been noted for future development.
+
+This is the user's question:
+{question}
+
+You must answer in the same language as users. 
+---
+
+### Response:
+"""
+)
+
+
+lectures_prompt = PromptTemplate(
+    input_variables=["context", "question"],
+    template="""
+You are an AI Teaching Assistant at THE LEARNING HOUSE. Your mission is to help learners better understand and engage with the course content.
+
+Below is a passage from the course the learner is currently studying. You are an expert in this field, and your role is to support the learner by doing any of the following:
+- Explain difficult parts in a simpler way
+- Provide relevant examples or analogies
+- Share fun or interesting facts
+- Ask questions to reinforce understanding
+- Summarize the content if needed
+
+Course content:
+{context}
+
+Now, here is the learner's question:
+{question}
+
+If none of the available content seems related to the learner's question, kindly inform them that we currently do not have suitable material for this request and that their feedback has been noted for future development.
+
+You must answer in the same language as users. 
+---
+
+### Response:
+"""
+)
+
+
+condense_prompt = PromptTemplate(
+    input_variables=["question", "chat_history"],
+    template="""
+Given the following conversation and a follow-up question, rephrase the follow-up question to be a standalone question.
+
+Chat History:
+{chat_history}
+
+Follow-Up Input:
+{question}
+
+Standalone question:
+
+You must answer in the same language as users. 
+"""
+)

services/api/chatbot/retrieval.py

@@ -0,0 +1,531 @@
+import os
+import re
+import hashlib
+import pymysql
+import qdrant_client
+import asyncio
+import aiomysql
+from dotenv import load_dotenv
+from langchain.schema import Document
+from langchain.vectorstores import Qdrant
+from langchain_huggingface import HuggingFaceEmbeddings
+from qdrant_client.http.models import PointIdsList, Distance, VectorParams
+from typing import List, Tuple, Dict, Set
+from .config import (
+    EMBEDDING_MODEL,
+    QDRANT_HOST,
+    QDRANT_API_KEY,
+    QDRANT_COLLECTION_NAME,
+    EMBEDDING_SIZE,
+    QDRANT_COLLECTION_NAME_LECTURES,
+)
+
+load_dotenv()
+
+#--- MySQL connection ---
+MYSQL_USER = os.getenv("MYSQL_USER")
+MYSQL_PASSWORD = os.getenv("MYSQL_PASSWORD")
+MYSQL_HOST = os.getenv("MYSQL_HOST")
+MYSQL_DB = os.getenv("MYSQL_DB")
+MYSQL_PORT = int(os.getenv("MYSQL_PORT", 3306))
+
+# Initialize embedding model with a more compatible configuration
+embedding_model = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/all-MiniLM-L6-v2",
+    model_kwargs={'device': 'cpu'},
+    encode_kwargs={'normalize_embeddings': True}
+)
+client = qdrant_client.QdrantClient(QDRANT_HOST, api_key=QDRANT_API_KEY)
+
+def connect_db():
+    return pymysql.connect(
+        host=MYSQL_HOST,
+        user=MYSQL_USER,
+        password=MYSQL_PASSWORD,
+        database=MYSQL_DB,
+        port=MYSQL_PORT,
+        cursorclass=pymysql.cursors.DictCursor,
+    )
+
+async def connect_db_async():
+    return await aiomysql.connect(
+        host=MYSQL_HOST,
+        user=MYSQL_USER,
+        password=MYSQL_PASSWORD,
+        database=MYSQL_DB,
+        port=MYSQL_PORT,
+        cursorclass=aiomysql.DictCursor,
+    )
+
+#---- Lectures processing
+
+def hash_lectures(l: dict) ->str:
+    text = "|".join([
+        str(l.get("CourseName", "")),
+        str(l.get("Descriptions", "")),
+        str(l.get("Skills", "")),
+        str(l.get("EstimatedDuration", "")),
+        str(l.get("Difficulty", "")),
+        str(l.get("AverageRating", "")),
+    ])
+    return hashlib.md5(text.encode("utf-8")).hexdigest()
+
+def load_sql_lectures():  # -> list[dict]
+    with connect_db() as conn:
+        with conn.cursor() as cursor:
+            cursor.execute("""
+                SELECT LectureID, Title, Description, Content
+                FROM Lectures
+            """)
+            return cursor.fetchall()
+
+async def load_sql_lectures_async() -> List[Dict]:
+    async with await connect_db_async() as conn:
+        async with conn.cursor() as cursor:
+            await cursor.execute("""
+                SELECT LectureID, Title, Description, Content
+                FROM Lectures
+            """)
+            return await cursor.fetchall()
+
+def convert_to_documents_lectures(lectures: list[dict]) -> list[Document]:
+    documents: list[Document] = []
+    for l in lectures:
+        parts = [
+            f"Lecture Title: {l.get('Title', 'No title')}", 
+            f"Description: {l.get('Description', 'No description')}",
+            f"Content: {l.get('Content', 'None')}",
+        ]
+        text = ", ".join(parts)
+        text = re.sub(r"\s+", " ", text).strip()
+
+        metadata = {
+            "LectureID": l["LectureID"],
+            "hash": hash_lectures(l)
+        }
+
+        documents.append(Document(page_content=text, metadata=metadata))
+    return documents
+
+def get_existing_qdrant_data_lectures() -> tuple[set[int], dict[int,str]]:
+    qdrant_ids: set[int] = set()
+    qdrant_hash_map: dict[int,str] = {}
+
+    scroll_offset = None
+    while True:
+        points, scroll_offset = client.scroll(
+            collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+            limit=1000,
+            with_payload=True,
+            offset=scroll_offset,
+        )
+        for pt in points:
+            cid = pt.payload["metadata"]["LectureID"]
+            qdrant_ids.add(cid)
+            qdrant_hash_map[cid] = pt.payload["metadata"].get("hash", "")
+        if scroll_offset is None:
+            break
+
+    return qdrant_ids, qdrant_hash_map
+
+async def get_existing_qdrant_data_lectures_async() -> Tuple[Set[int], Dict[int, str]]:
+    qdrant_ids: set[int] = set()
+    qdrant_hash_map: dict[int,str] = {}
+
+    scroll_offset = None
+    while True:
+        # Note: client.scroll is synchronous but we're keeping the async pattern
+        points, scroll_offset = client.scroll(
+            collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+            limit=1000,
+            with_payload=True,
+            offset=scroll_offset,
+        )
+        for pt in points:
+            cid = pt.payload["metadata"]["LectureID"]
+            qdrant_ids.add(cid)
+            qdrant_hash_map[cid] = pt.payload["metadata"].get("hash", "")
+        if scroll_offset is None:
+            break
+
+    return qdrant_ids, qdrant_hash_map
+
+def sync_lectures_to_qdrant():
+    cols = client.get_collections().collections
+    if not any(c.name == QDRANT_COLLECTION_NAME_LECTURES for c in cols):
+        client.create_collection(
+            collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+            vectors_config=VectorParams(size=EMBEDDING_SIZE, distance=Distance.COSINE),
+        )
+
+    # 2) Load data from MySQL
+    db_lectures = load_sql_lectures()
+    db_map = {l["LectureID"]: l for l in db_lectures}
+    db_ids = set(db_map.keys())
+
+    # 3) Load data from Qdrant
+    qdrant_ids, qdrant_hash_map = get_existing_qdrant_data_lectures()
+
+    # 4) detemine new / removed / updated
+    new_ids     = db_ids - qdrant_ids
+    removed_ids = qdrant_ids - db_ids
+    updated_ids = {
+        cid
+        for cid in db_ids & qdrant_ids
+        if hash_lectures(db_map[cid]) != qdrant_hash_map.get(cid, "")
+    }
+
+    # 5) Upsert & update
+    to_upsert = [db_map[cid] for cid in new_ids | updated_ids]
+    if to_upsert:
+        docs = convert_to_documents_lectures(to_upsert)
+        vs = Qdrant(
+            client=client,
+            collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+            embeddings=embedding_model,
+            content_payload_key="page_content",
+            metadata_payload_key="metadata",
+        )
+        vs.add_documents(docs)
+        print(f"Added/Updated: {len(docs)} documents.")
+
+    # 6) Delete Unavailable courses
+    if removed_ids:
+        client.delete(
+            collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+            points_selector=PointIdsList(points=list(removed_ids)),
+        )
+        print(f"Removed: {len(removed_ids)} documents.")
+
+    print(
+        f"Sync completed. "
+        f"New: {len(new_ids)}, "
+        f"Updated: {len(updated_ids)}, "
+        f"Removed: {len(removed_ids)}"
+    )
+    collection_info = client.get_collection(QDRANT_COLLECTION_NAME_LECTURES)
+    total_points = collection_info.points_count
+    print(f"Number of vector in Vectordb: {total_points}")
+
+async def sync_lectures_to_qdrant_async():
+    cols = client.get_collections().collections
+    if not any(c.name == QDRANT_COLLECTION_NAME_LECTURES for c in cols):
+        client.create_collection(
+            collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+            vectors_config=VectorParams(size=EMBEDDING_SIZE, distance=Distance.COSINE),
+        )
+
+    # 2) Load data from MySQL
+    db_lectures = await load_sql_lectures_async()
+    db_map = {l["LectureID"]: l for l in db_lectures}
+    db_ids = set(db_map.keys())
+
+    # 3) Load data from Qdrant
+    qdrant_ids, qdrant_hash_map = await get_existing_qdrant_data_lectures_async()
+
+    # 4) determine new / removed / updated
+    new_ids     = db_ids - qdrant_ids
+    removed_ids = qdrant_ids - db_ids
+    updated_ids = {
+        cid
+        for cid in db_ids & qdrant_ids
+        if hash_lectures(db_map[cid]) != qdrant_hash_map.get(cid, "")
+    }
+
+    # 5) Upsert & update
+    to_upsert = [db_map[cid] for cid in new_ids | updated_ids]
+    if to_upsert:
+        docs = convert_to_documents_lectures(to_upsert)
+        vs = Qdrant(
+            client=client,
+            collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+            embeddings=embedding_model,
+            content_payload_key="page_content",
+            metadata_payload_key="metadata",
+        )
+        await asyncio.to_thread(vs.add_documents, docs)
+        print(f"Added/Updated: {len(docs)} documents.")
+
+    # 6) Delete Unavailable courses
+    if removed_ids:
+        await asyncio.to_thread(
+            client.delete,
+            collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+            points_selector=PointIdsList(points=list(removed_ids)),
+        )
+        print(f"Removed: {len(removed_ids)} documents.")
+
+    print(
+        f"Sync completed. "
+        f"New: {len(new_ids)}, "
+        f"Updated: {len(updated_ids)}, "
+        f"Removed: {len(removed_ids)}"
+    )
+    collection_info = client.get_collection(QDRANT_COLLECTION_NAME_LECTURES)
+    total_points = collection_info.points_count
+    print(f"Number of vectors in Vectordb: {total_points}")
+
+def get_vectorstore_lectures() -> Qdrant:
+    return Qdrant(
+        client=client,
+        collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+        embeddings=embedding_model,
+        content_payload_key="page_content",
+        metadata_payload_key="metadata",
+    )
+
+def get_vectorstore() -> Qdrant:
+    """Alias for get_vectorstore_lectures for backward compatibility"""
+    return get_vectorstore_lectures()
+
+async def reset_qdrant_collection_async():
+    collections = client.get_collections().collections
+    if any(c.name == QDRANT_COLLECTION_NAME_LECTURES for c in collections):
+        await asyncio.to_thread(client.delete_collection, QDRANT_COLLECTION_NAME_LECTURES)
+        print(f"Đã xoá collection: {QDRANT_COLLECTION_NAME_LECTURES}")
+
+    await asyncio.to_thread(
+        client.create_collection,
+        collection_name=QDRANT_COLLECTION_NAME_LECTURES,
+        vectors_config=VectorParams(size=EMBEDDING_SIZE, distance=Distance.COSINE),
+    )
+    print(f"Đã khởi tạo lại collection: {QDRANT_COLLECTION_NAME_LECTURES}")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#---- Courses processing
+def hash_course(c: dict) -> str:
+    text = "|".join([
+        str(c.get("CourseName", "")),
+        str(c.get("Descriptions", "")),
+        str(c.get("Skills", "")),
+        str(c.get("EstimatedDuration", "")),
+        str(c.get("Difficulty", "")),
+        str(c.get("AverageRating", "")),
+    ])
+    return hashlib.md5(text.encode("utf-8")).hexdigest()
+
+def load_sql(): #-> list[dict]
+    with connect_db() as conn:
+        with conn.cursor() as cursor:
+            cursor.execute("SELECT * FROM Courses")
+            return cursor.fetchall()
+
+async def load_sql_async() -> List[Dict]:
+    async with await connect_db_async() as conn:
+        async with conn.cursor() as cursor:
+            await cursor.execute("SELECT * FROM Courses")
+            return await cursor.fetchall()
+
+def convert_to_documents(courses: list[dict]) -> list[Document]:
+    documents: list[Document] = []
+    for c in courses:
+        # 1) Build the textual content
+        parts = [
+            f"CourseName: {c.get('CourseName', 'No title')}",
+            f"Descriptions: {c.get('Descriptions', 'No description')}",
+            f"Skills: {c.get('Skills', 'None')}",
+            f"EstimatedDuration (hours): {c.get('EstimatedDuration', 'Unknown')}",
+            f"Difficulty: {c.get('Difficulty', 'Unknown')}",
+            f"AverageRating: {c.get('AverageRating', '0.00')}",
+        ]
+        text = ", ".join(parts)
+        text = re.sub(r"\s+", " ", text).strip()
+
+        # 2) Assemble metadata
+        metadata = {
+            "CourseID": c["CourseID"],
+            "Skills": c.get("Skills", ""),
+            "EstimatedDuration": c.get("EstimatedDuration", 0),
+            "Difficulty": c.get("Difficulty", ""),
+            "AverageRating": float(c.get("AverageRating", 0.0)),
+            "hash": hash_course(c),
+        }
+
+        documents.append(Document(page_content=text, metadata=metadata))
+    return documents
+
+
+def get_existing_qdrant_data() -> tuple[set[int], dict[int,str]]:
+    qdrant_ids: set[int] = set()
+    qdrant_hash_map: dict[int,str] = {}
+
+    scroll_offset = None
+    while True:
+        points, scroll_offset = client.scroll(
+            collection_name=QDRANT_COLLECTION_NAME,
+            limit=1000,
+            with_payload=True,
+            offset=scroll_offset,
+        )
+        for pt in points:
+            cid = pt.payload["metadata"]["CourseID"]
+            qdrant_ids.add(cid)
+            qdrant_hash_map[cid] = pt.payload["metadata"].get("hash", "")
+        if scroll_offset is None:
+            break
+
+    return qdrant_ids, qdrant_hash_map
+
+async def get_existing_qdrant_data_async() -> Tuple[Set[int], Dict[int, str]]:
+    qdrant_ids: set[int] = set()
+    qdrant_hash_map: dict[int,str] = {}
+
+    scroll_offset = None
+    while True:
+        points, scroll_offset = client.scroll(
+            collection_name=QDRANT_COLLECTION_NAME,
+            limit=1000,
+            with_payload=True,
+            offset=scroll_offset,
+        )
+        for pt in points:
+            cid = pt.payload["metadata"]["CourseID"]
+            qdrant_ids.add(cid)
+            qdrant_hash_map[cid] = pt.payload["metadata"].get("hash", "")
+        if scroll_offset is None:
+            break
+
+    return qdrant_ids, qdrant_hash_map
+
+def sync_courses_to_qdrant():
+    cols = client.get_collections().collections
+    if not any(c.name == QDRANT_COLLECTION_NAME for c in cols):
+        client.create_collection(
+            collection_name=QDRANT_COLLECTION_NAME,
+            vectors_config=VectorParams(size=EMBEDDING_SIZE, distance=Distance.COSINE),
+        )
+
+    # 2) Load data from MySQL
+    db_courses = load_sql()
+    db_map = {c["CourseID"]: c for c in db_courses}
+    db_ids = set(db_map.keys())
+
+    # 3) Load data from Qdrant
+    qdrant_ids, qdrant_hash_map = get_existing_qdrant_data()
+
+    # 4) detemine new / removed / updated
+    new_ids     = db_ids - qdrant_ids
+    removed_ids = qdrant_ids - db_ids
+    updated_ids = {
+        cid
+        for cid in db_ids & qdrant_ids
+        if hash_course(db_map[cid]) != qdrant_hash_map.get(cid, "")
+    }
+
+    # 5) Upsert & update
+    to_upsert = [db_map[cid] for cid in new_ids | updated_ids]
+    if to_upsert:
+        docs = convert_to_documents(to_upsert)
+        vs = Qdrant(
+            client=client,
+            collection_name=QDRANT_COLLECTION_NAME,
+            embeddings=embedding_model,
+            content_payload_key="page_content",
+            metadata_payload_key="metadata",
+        )
+        vs.add_documents(docs)
+        print(f"Added/Updated: {len(docs)} documents.")
+
+    # 6) Delete Unavailable courses
+    if removed_ids:
+        client.delete(
+            collection_name=QDRANT_COLLECTION_NAME,
+            points_selector=PointIdsList(points=list(removed_ids)),
+        )
+        print(f"🗑 Removed: {len(removed_ids)} documents.")
+
+    print(
+        f"Sync completed. "
+        f"New: {len(new_ids)}, "
+        f"Updated: {len(updated_ids)}, "
+        f"Removed: {len(removed_ids)}"
+    )
+    collection_info = client.get_collection(QDRANT_COLLECTION_NAME)
+    total_points = collection_info.points_count
+    print(f"Number of vector in Vectordb: {total_points}")
+
+async def sync_courses_to_qdrant_async():
+    cols = client.get_collections().collections
+    if not any(c.name == QDRANT_COLLECTION_NAME for c in cols):
+        client.create_collection(
+            collection_name=QDRANT_COLLECTION_NAME,
+            vectors_config=VectorParams(size=EMBEDDING_SIZE, distance=Distance.COSINE),
+        )
+
+    # 2) Load data from MySQL
+    db_courses = await load_sql_async()
+    db_map = {c["CourseID"]: c for c in db_courses}
+    db_ids = set(db_map.keys())
+
+    # 3) Load data from Qdrant
+    qdrant_ids, qdrant_hash_map = await get_existing_qdrant_data_async()
+
+    # 4) determine new / removed / updated
+    new_ids     = db_ids - qdrant_ids
+    removed_ids = qdrant_ids - db_ids
+    updated_ids = {
+        cid
+        for cid in db_ids & qdrant_ids
+        if hash_course(db_map[cid]) != qdrant_hash_map.get(cid, "")
+    }
+
+    # 5) Upsert & update
+    to_upsert = [db_map[cid] for cid in new_ids | updated_ids]
+    if to_upsert:
+        docs = convert_to_documents(to_upsert)
+        vs = Qdrant(
+            client=client,
+            collection_name=QDRANT_COLLECTION_NAME,
+            embeddings=embedding_model,
+            content_payload_key="page_content",
+            metadata_payload_key="metadata",
+        )
+        await asyncio.to_thread(vs.add_documents, docs)
+        print(f"Added/Updated: {len(docs)} documents.")
+
+    # 6) Delete Unavailable courses
+    if removed_ids:
+        await asyncio.to_thread(
+            client.delete,
+            collection_name=QDRANT_COLLECTION_NAME,
+            points_selector=PointIdsList(points=list(removed_ids)),
+        )
+        print(f"🗑 Removed: {len(removed_ids)} documents.")
+
+    print(
+        f"Sync completed. "
+        f"New: {len(new_ids)}, "
+        f"Updated: {len(updated_ids)}, "
+        f"Removed: {len(removed_ids)}"
+    )
+
+
+def reset_qdrant_collection():
+    collections = client.get_collections().collections
+    if any(c.name == QDRANT_COLLECTION_NAME for c in collections):
+        client.delete_collection(QDRANT_COLLECTION_NAME)
+        print(f"Đã xoá collection: {QDRANT_COLLECTION_NAME}")
+
+    client.create_collection(
+        collection_name=QDRANT_COLLECTION_NAME,
+        vectors_config=VectorParams(size=EMBEDDING_SIZE, distance=Distance.COSINE),
+    )
+    print(f"Đã khởi tạo lại collection: {QDRANT_COLLECTION_NAME}")

services/api/db/auth.py

@@ -0,0 +1,437 @@
+"""
+auth.py  –  Lightweight authentication micro-service
+----------------------------------------------------
+• Exposes /auth/verify_user  (login check)
+• Optional /auth/register_user for sign-up
+• Uses MySQL, bcrypt, and Pydantic
+• No Streamlit, cookies, or front-end logic
+"""
+
+from fastapi import FastAPI, Request, Response, Cookie, HTTPException, Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import OAuth2PasswordRequestForm
+from jose import jwt, JWTError
+from pydantic import BaseModel
+from dotenv import load_dotenv
+import os
+import time
+import requests
+import os
+import pymysql
+import bcrypt
+import sys
+import importlib.util
+from services.api.db.token_utils import create_token, decode_token
+from sqlalchemy.orm import Session
+
+# Add parent directory to path to enable imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Create FastAPI app
+app = FastAPI()
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000, https://tlong-ds.github.io/thelearninghouse/"],  # Your React frontend URL
+    allow_credentials=True,  # Important for cookies
+    allow_methods=["*"],
+    allow_headers=["*"],
+    expose_headers=["*"]
+)
+
+# Import API endpoints
+try:
+    from services.api.api_endpoints import router as api_router
+except ImportError:
+    # Try a different import strategy for direct module execution
+    spec = importlib.util.spec_from_file_location(
+        "api_endpoints", 
+        os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "api_endpoints.py")
+    )
+    api_endpoints = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(api_endpoints)
+    api_router = api_endpoints.router
+
+
+# Load environment variables
+load_dotenv()
+SECRET_KEY = os.getenv("SECRET_TOKEN", "dev-secret")
+ALGORITHM = os.getenv("ALGORITHM", "HS256")
+MYSQL_USER = os.getenv("MYSQL_USER")
+MYSQL_PASSWORD = os.getenv("MYSQL_PASSWORD")
+MYSQL_HOST = os.getenv("MYSQL_HOST", "localhost")
+MYSQL_DB = os.getenv("MYSQL_DB")
+MYSQL_PORT = int(os.getenv("MYSQL_PORT", "3306"))
+
+
+
+# Initialize FastAPI app
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:8503", "http://localhost:3000", "http://127.0.0.1:3000", "https://tlong-ds.github.io"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allow_headers=["*"],
+    expose_headers=["*"],
+)
+
+# Import and include chat router
+try:
+    from services.api.chat_endpoints import router as chat_router
+except ImportError:
+    spec = importlib.util.spec_from_file_location(
+        "chat_endpoints", 
+        os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "chat_endpoints.py")
+    )
+    chat_endpoints = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(chat_endpoints)
+    chat_router = chat_endpoints.router
+
+# Debug print of available routes
+print("DEBUG: Available routes in api_router:")
+for route in api_router.routes:
+    print(f"Route: {route.path}, Methods: {route.methods}")
+
+# Include API routers
+app.include_router(api_router)
+app.include_router(chat_router, prefix="/api")
+
+
+class LoginPayload(BaseModel):
+    username: str
+    password: str
+    role: str
+
+class PasswordChangePayload(BaseModel):
+    current_password: str
+    new_password: str
+
+class PasswordChangePayload(BaseModel):
+    current_password: str
+    new_password: str
+
+# Token functions moved to token_utils.py
+
+@app.post("/login")
+async def login(response: Response, payload: LoginPayload):
+    try:
+        print(f"Login attempt: {payload.username}, role: {payload.role}")
+        
+        # Directly verify the user credentials
+        table_map = {
+            "Learner": "Learners",
+            "Instructor": "Instructors"
+        }
+        table = table_map.get(payload.role)
+        if not table:
+            print(f"Invalid role: {payload.role}")
+            raise HTTPException(status_code=400, detail="Invalid role")
+
+        conn = connect_db()
+        try:
+            with conn.cursor() as cur:
+                query = f"SELECT Password FROM {table} WHERE AccountName=%s LIMIT 1"
+                print(f"Executing query: {query} with username: {payload.username}")
+                
+                cur.execute(query, (payload.username,))
+                row = cur.fetchone()
+                
+                if not row:
+                    print(f"No user found with username: {payload.username} in table: {table}")
+                    raise HTTPException(status_code=401, detail="Incorrect username or password")
+                    
+                password_valid = check_password(payload.password, row[0])
+                print(f"Password check result: {password_valid}")
+                
+                if not password_valid:
+                    print(f"Authentication failed: Invalid password")
+                    raise HTTPException(status_code=401, detail="Incorrect username or password")
+        except Exception as db_err:
+            print(f"Database error: {str(db_err)}")
+            raise HTTPException(status_code=500, detail=f"Database error: {str(db_err)}")
+        finally:
+            conn.close()
+        
+        # User authenticated successfully
+        user_data = {"username": payload.username, "role": payload.role}
+        print(f"Authentication successful for: {payload.username}")
+        
+        token = create_token(user_data)
+        response.set_cookie(
+            key="auth_token",
+            value=token,
+            httponly=False,  # Cookie cannot be accessed by JavaScript
+            samesite="Lax",  # More secure than None
+            secure=True,  # Only send cookie over HTTPS
+            path="/",
+            max_age=604800  # 7 days
+        )
+        return {
+            "message": f"Login successful for {user_data['username']}", 
+            "username": user_data["username"], 
+            "role": user_data["role"],
+            "token": token
+        }
+    except Exception as e:
+        print(f"Login exception: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Login error: {str(e)}")
+
+@app.get("/logout")
+def logout(response: Response):
+    response.delete_cookie("auth_token")
+    return HTMLResponse("<h3>Logged out — cookie cleared!</h3>")
+
+@app.get("/whoami")
+async def whoami(auth_token: str = Cookie(None)):
+    payload = decode_token(auth_token)
+    return {"username": payload["username"], "role": payload["role"]}
+
+@app.get("/protected")
+def protected_route(auth_token: str = Cookie(None)):
+    payload = decode_token(auth_token)
+    return {"msg": "Access granted", "user": payload}
+
+@app.put("/api/user/password")
+async def change_password(payload: PasswordChangePayload, request: Request, auth_token: str = Cookie(None)):
+    """Change user password endpoint."""
+    # Get token from cookie or Authorization header
+    token = auth_token
+    if not token and "Authorization" in request.headers:
+        auth_header = request.headers["Authorization"]
+        if auth_header.startswith("Bearer "):
+            token = auth_header[7:]  # Remove 'Bearer ' prefix
+    
+    if not token:
+        raise HTTPException(status_code=401, detail="No authentication token provided")
+    try:
+        # Decode token to get user info
+        user_data = decode_token(token)
+        if not user_data:
+            raise HTTPException(status_code=401, detail="Invalid token")
+
+        username = user_data["username"]
+        role = user_data["role"]
+
+        # Get the correct table based on role
+        table_map = {
+            "Learner": "Learners",
+            "Instructor": "Instructors"
+        }
+        table = table_map.get(role)
+        if not table:
+            raise HTTPException(status_code=400, detail="Invalid role")
+
+        conn = connect_db()
+        try:
+            with conn.cursor() as cur:
+                # First verify current password
+                query = f"SELECT Password FROM {table} WHERE AccountName=%s LIMIT 1"
+                cur.execute(query, (username,))
+                row = cur.fetchone()
+
+                if not row or not check_password(payload.current_password, row[0]):
+                    raise HTTPException(status_code=401, detail="Current password is incorrect")
+
+                # Hash the new password
+                new_password_hash = hash_password(payload.new_password)
+
+                # Update the password
+                update_query = f"UPDATE {table} SET Password=%s WHERE AccountName=%s"
+                cur.execute(update_query, (new_password_hash, username))
+                conn.commit()
+
+                return {"message": "Password updated successfully"}
+
+        except Exception as db_err:
+            conn.rollback()
+            print(f"Database error: {str(db_err)}")
+            raise HTTPException(status_code=500, detail=f"Database error: {str(db_err)}")
+        finally:
+            conn.close()
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Unexpected error in change_password: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+def connect_db():
+    return pymysql.connect(
+        host=MYSQL_HOST,
+        user=MYSQL_USER,
+        password=MYSQL_PASSWORD,
+        database=MYSQL_DB,
+        port=MYSQL_PORT
+    )
+
+def check_password(plain: str, hashed: str) -> bool:
+    """Compare plaintext vs bcrypt hash stored in DB."""
+    return bcrypt.checkpw(plain.encode("utf-8"), hashed.encode("utf-8"))
+
+def hash_password(plain: str) -> str:
+    """Return bcrypt hash for storage."""
+    return bcrypt.hashpw(plain.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
+
+# ───────────────────────────────────────────��────────────────────────────────────
+#  Pydantic models
+# ────────────────────────────────────────────────────────────────────────────────
+class UserCredentials(BaseModel):
+    username: str
+    password: str
+    role: str  # "Learner" or "Instructor"
+
+class NewUser(UserCredentials):
+    name: str
+    email: str
+
+
+@app.post("/auth/verify_user")
+def verify_user(creds: UserCredentials):
+    """
+    Validate user credentials.
+    Returns {username, role} on success; 401 on failure.
+    """
+    try:
+        print(f"Verify user attempt for: {creds.username}, role: {creds.role}")
+        
+        table_map = {
+            "Learner": "Learners",
+            "Instructor": "Instructors"
+        }
+        table = table_map.get(creds.role)
+        if not table:
+            print(f"Invalid role: {creds.role}")
+            raise HTTPException(status_code=400, detail="Invalid role")
+
+        conn = connect_db()
+        try:
+            with conn.cursor() as cur:
+                query = f"SELECT Password FROM {table} WHERE AccountName=%s LIMIT 1"
+                print(f"Executing query: {query} with username: {creds.username}")
+                
+                cur.execute(query, (creds.username,))
+                row = cur.fetchone()
+                
+                if not row:
+                    print(f"No user found with username: {creds.username} in table: {table}")
+        except Exception as db_err:
+            print(f"Database error: {str(db_err)}")
+            raise HTTPException(status_code=500, detail=f"Database error: {str(db_err)}")
+        finally:
+            conn.close()
+
+        if not row:
+            print(f"Authentication failed: User not found")
+            raise HTTPException(status_code=401, detail="Incorrect username or password")
+            
+        password_valid = check_password(creds.password, row[0])
+        print(f"Password check result: {password_valid}")
+        
+        if not password_valid:
+            print(f"Authentication failed: Invalid password")
+            raise HTTPException(status_code=401, detail="Incorrect username or password")
+
+        print(f"Authentication successful for: {creds.username}")
+        return {"username": creds.username, "role": creds.role}
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"Unexpected error in verify_user: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+
+@app.post("/auth/register_user")
+def register_user(user: NewUser):
+    """
+    Simple sign-up endpoint.
+    Returns 201 Created on success, 409 if username/email exists.
+    """
+    table_cfg = {
+        "Learner": ("Learners", "LearnerName"),
+        "Instructor": ("Instructors", "InstructorName")
+    }
+    cfg = table_cfg.get(user.role)
+    if not cfg:
+        raise HTTPException(status_code=400, detail="Invalid role")
+
+    table, name_col = cfg
+    hashed_pw = hash_password(user.password)
+
+    conn = connect_db()
+    try:
+        with conn.cursor() as cur:
+            # Uniqueness check
+            cur.execute(
+                f"SELECT 1 FROM {table} WHERE AccountName=%s OR Email=%s LIMIT 1",
+                (user.username, user.email)
+            )
+            if cur.fetchone():
+                raise HTTPException(status_code=409, detail="Username or email already exists")
+
+            # Insert new record
+            cur.execute(
+                f"INSERT INTO {table} ({name_col}, Email, AccountName, Password) "
+                f"VALUES (%s, %s, %s, %s)",
+                (user.name, user.email, user.username, hashed_pw)
+            )
+            conn.commit()
+    finally:
+        conn.close()
+
+    return {"msg": "User created", "username": user.username, "role": user.role}, 201
+
+
+@app.post("/api/auth/logout")
+async def logout():
+    response = JSONResponse(content={"message": "Logged out successfully"})
+    # Clear all auth-related cookies
+    response.delete_cookie(key="auth_token", path="/")
+    response.delete_cookie(key="session_id", path="/")
+    return response
+
+@app.get("/api/users")
+async def get_users(role: str):
+    table_map = {
+        "Learner": "Learners",
+        "Instructor": "Instructors"
+    }
+    table = table_map.get(role)
+    if not table:
+        raise HTTPException(status_code=400, detail="Invalid role")
+    
+    conn = connect_db()
+    try:
+        with conn.cursor() as cur:
+            cur.execute(f"SELECT * FROM {table}")
+            columns = [desc[0] for desc in cur.description]
+            users = [dict(zip(columns, row)) for row in cur.fetchall()]
+            return users
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        conn.close()
+
+@app.get("/api/statistics/users/count")
+async def get_user_count(role: str):
+    table_map = {
+        "Learner": "Learners",
+        "Instructor": "Instructors"
+    }
+    table = table_map.get(role)
+    if not table:
+        raise HTTPException(status_code=400, detail="Invalid role")
+    
+    conn = connect_db()
+    try:
+        with conn.cursor() as cur:
+            cur.execute(f"SELECT COUNT(*) FROM {table}")
+            count = cur.fetchone()[0]
+            return {"count": count}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        conn.close()

services/api/db/token_utils.py

@@ -0,0 +1,50 @@
+"""
+token_utils.py - JWT token utilities for authentication
+------------------------------------------------------
+This module contains functions for JWT token encoding and decoding
+Extracted to avoid circular imports between auth.py and api_endpoints.py
+"""
+
+from fastapi import HTTPException
+from jose import jwt, JWTError
+import time
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+SECRET_KEY = os.getenv("SECRET_TOKEN", "somesecretkey")
+ALGORITHM = os.getenv("ALGORITHM", "HS256")
+
+def create_token(data: dict, expires_in: int = 86400):
+    """
+    Create a JWT token from user data
+    
+    Args:
+        data: Dictionary containing user information
+        expires_in: Token expiration time in seconds (default: 24 hours)
+        
+    Returns:
+        JWT token string
+    """
+    to_encode = data.copy()
+    to_encode.update({"exp": time.time() + expires_in})
+    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+
+def decode_token(token: str):
+    """
+    Decode and validate a JWT token
+    
+    Args:
+        token: JWT token string
+        
+    Returns:
+        Dictionary with decoded token data
+        
+    Raises:
+        HTTPException: If token is invalid or expired
+    """
+    try:
+        return jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+    except JWTError:
+        raise HTTPException(status_code=403, detail="Invalid or expired token")

services/api/skills.csv

@@ -0,0 +1,21 @@
+skill,
+"Computer Science",
+"Fundamentals",
+"Advanced Techniques",
+"Mathematics",
+"Data Science",
+"Economics",
+"Finance",
+"Marketing",
+"Graphic Design",
+"English Language",
+"Project Management",
+"Web Development",
+"Artificial Intelligence",
+"Cryptography",
+"Network Security",
+"Business Analysis",
+"Human Resources",
+"Digital Marketing",
+"Entrepreneurship",
+"Public Speaking"