Merge branch 'master'

backend/Dockerfile

@@ -31,5 +31,10 @@ RUN chmod +x start.sh
 # Expose the port the app runs on
 EXPOSE 8000
 
-# Run the application (with migrations first)
-CMD ["./start.sh"]
+# Create an entrypoint script to handle database seeding
+COPY docker-entrypoint.sh /usr/local/bin/
+RUN chmod +x /usr/local/bin/docker-entrypoint.sh
+
+# Run the application
+ENTRYPOINT ["/usr/local/bin/docker-entrypoint.sh"]
+CMD ["python", "main.py"]

backend/alembic/versions/c5ca6901e3cd_seed_applications_with_realistic_data.py

@@ -0,0 +1,35 @@
+"""Seed applications with realistic data
+
+Revision ID: c5ca6901e3cd
+Revises: 290ee4ce077e
+Create Date: 2026-02-09 12:36:16.911612
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'c5ca6901e3cd'
+down_revision: Union[str, Sequence[str], None] = '290ee4ce077e'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    # We don't need to make any schema changes here, just insert data
+    # The schema changes were already applied in the previous migration
+    # Applications were seeded separately using a script
+    pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###

backend/db_seeder.py

@@ -0,0 +1,331 @@
+"""
+Module to handle database seeding for the application.
+This module provides functionality to seed the database with initial data
+when the application starts for the first time.
+"""
+
+import logging
+from sqlalchemy import inspect
+from models.user import User
+from models.job import Job
+from models.assessment import Assessment
+from services.user_service import create_user
+from services.job_service import create_job
+from services.assessment_service import create_assessment
+from services.application_service import create_application
+from schemas.user import UserCreate
+from schemas.job import JobCreate
+from schemas.assessment import AssessmentCreate
+from schemas.application import ApplicationCreate, ApplicationAnswer
+from schemas.enums import UserRole, JobSeniority, QuestionType
+from passlib.context import CryptContext
+import json
+
+# Create logger for this module
+logger = logging.getLogger(__name__)
+
+# Password hashing context
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def hash_password(password: str) -> str:
+    """Hash a password using bcrypt."""
+    return pwd_context.hash(password)
+
+def check_if_seeded(db) -> bool:
+    """Check if the database has already been seeded with initial data."""
+    inspector = inspect(db.bind)
+    
+    # Check if we have any users in the database
+    user_count = db.query(User).count()
+    
+    # If we have users, we consider the DB as seeded
+    # (in a real-world scenario, you might want a more sophisticated check)
+    return user_count > 0
+
+def seed_database():
+    """Seed the database with initial data if it hasn't been seeded yet."""
+    from database.database import SessionLocal
+    
+    # Create tables if they don't exist
+    from models.base import Base
+    from database.database import engine
+    Base.metadata.create_all(bind=engine)
+    
+    db = SessionLocal()
+    
+    try:
+        # Check if database is already seeded
+        if check_if_seeded(db):
+            logger.info("Database already seeded. Skipping seeding process.")
+            return
+        
+        logger.info("Database is not seeded. Starting seeding process...")
+        
+        # Create HR users
+        hr_users_data = [
+            {
+                "first_name": "Sarah",
+                "last_name": "Johnson",
+                "email": "sarah.johnson@demo.com",
+                "password": "password123",
+                "role": UserRole.hr
+            },
+            {
+                "first_name": "Michael",
+                "last_name": "Chen",
+                "email": "michael.chen@demo.com",
+                "password": "password123",
+                "role": UserRole.hr
+            },
+            {
+                "first_name": "Emma",
+                "last_name": "Rodriguez",
+                "email": "emma.rodriguez@demo.com",
+                "password": "password123",
+                "role": UserRole.hr
+            },
+            {
+                "first_name": "David",
+                "last_name": "Wilson",
+                "email": "david.wilson@demo.com",
+                "password": "password123",
+                "role": UserRole.hr
+            }
+        ]
+        
+        hr_users = []
+        for user_data in hr_users_data:
+            user_create = UserCreate(
+                first_name=user_data["first_name"],
+                last_name=user_data["last_name"],
+                email=user_data["email"],
+                password=user_data["password"],
+                role=user_data["role"]
+            )
+            user = create_user(db, user_create)
+            hr_users.append(user)
+            logger.info(f"Created HR user: {user.email}")
+        
+        # Create candidate users
+        candidate_users_data = [
+            {
+                "first_name": "Alex",
+                "last_name": "Thompson",
+                "email": "alex.thompson@demo.com",
+                "password": "password123",
+                "role": UserRole.applicant
+            },
+            {
+                "first_name": "Jessica",
+                "last_name": "Lee",
+                "email": "jessica.lee@demo.com",
+                "password": "password123",
+                "role": UserRole.applicant
+            },
+            {
+                "first_name": "Ryan",
+                "last_name": "Patel",
+                "email": "ryan.patel@demo.com",
+                "password": "password123",
+                "role": UserRole.applicant
+            },
+            {
+                "first_name": "Olivia",
+                "last_name": "Kim",
+                "email": "olivia.kim@demo.com",
+                "password": "password123",
+                "role": UserRole.applicant
+            }
+        ]
+        
+        candidate_users = []
+        for user_data in candidate_users_data:
+            user_create = UserCreate(
+                first_name=user_data["first_name"],
+                last_name=user_data["last_name"],
+                email=user_data["email"],
+                password=user_data["password"],
+                role=user_data["role"]
+            )
+            user = create_user(db, user_create)
+            candidate_users.append(user)
+            logger.info(f"Created candidate user: {user.email}")
+        
+        # Create sample jobs
+        jobs_data = [
+            {
+                "title": "Software Engineer",
+                "seniority": JobSeniority.mid,
+                "description": "Develop and maintain software applications using modern technologies.",
+                "skill_categories": ["python", "javascript", "sql", "rest-api"]
+            },
+            {
+                "title": "Senior Python Developer",
+                "seniority": JobSeniority.senior,
+                "description": "Lead development of complex Python applications and mentor junior developers.",
+                "skill_categories": ["python", "django", "flask", "postgresql", "aws"]
+            },
+            {
+                "title": "Junior Data Analyst",
+                "seniority": JobSeniority.junior,
+                "description": "Analyze data to provide insights and support business decisions.",
+                "skill_categories": ["sql", "python", "excel", "data-visualization"]
+            },
+            {
+                "title": "DevOps Engineer",
+                "seniority": JobSeniority.mid,
+                "description": "Manage infrastructure and deployment pipelines.",
+                "skill_categories": ["docker", "kubernetes", "aws", "ci-cd", "linux"]
+            }
+        ]
+        
+        jobs = []
+        for job_data in jobs_data:
+            job_create = JobCreate(
+                title=job_data["title"],
+                seniority=job_data["seniority"],
+                description=job_data["description"],
+                skill_categories=job_data["skill_categories"]
+            )
+            job = create_job(db, job_create)
+            jobs.append(job)
+            logger.info(f"Created job: {job.title}")
+        
+        # Create assessments for each job
+        assessment_templates = [
+            {
+                "title": "Programming Skills Assessment",
+                "passing_score": 60,
+                "questions_types": [QuestionType.choose_one, QuestionType.text_based]
+            },
+            {
+                "title": "Data Analysis Skills Assessment",
+                "passing_score": 65,
+                "questions_types": [QuestionType.choose_one, QuestionType.choose_many, QuestionType.text_based]
+            },
+            {
+                "title": "DevOps Practices Assessment",
+                "passing_score": 70,
+                "questions_types": [QuestionType.choose_one, QuestionType.text_based]
+            }
+        ]
+        
+        assessments = []
+        for i, job in enumerate(jobs):
+            template = assessment_templates[i % len(assessment_templates)]
+            assessment_create = AssessmentCreate(
+                title=template["title"],
+                passing_score=template["passing_score"],
+                questions_types=template["questions_types"]
+            )
+            assessment = create_assessment(db, job.id, assessment_create)
+            assessments.append(assessment)
+            logger.info(f"Created assessment: {assessment.title} for job {job.title}")
+        
+        # Create some sample applications with realistic answers and scores
+        # For each assessment, create applications from different candidates
+        for i, assessment in enumerate(assessments):
+            # Get the job for this assessment
+            job = next((j for j in jobs if j.id == assessment.job_id), None)
+            if not job:
+                continue
+            
+            # Get questions from the assessment
+            try:
+                questions = json.loads(assessment.questions) if assessment.questions else []
+            except json.JSONDecodeError:
+                logger.warning(f"Could not parse questions for assessment {assessment.id}")
+                continue
+            
+            if not questions:
+                continue
+            
+            # Select a few candidate users to apply for this job
+            selected_candidates = candidate_users[:3]  # Use first 3 candidates
+            
+            for j, user in enumerate(selected_candidates):
+                # Generate answers for each question
+                answers = []
+                
+                for k, question in enumerate(questions):
+                    answer = {
+                        "question_id": question["id"],
+                        "text": None,
+                        "options": []
+                    }
+                    
+                    if question["type"] == "choose_one":
+                        # For multiple choice questions, vary correctness
+                        if j == 0:  # First candidate gets some wrong
+                            answer["options"] = [question.get("correct_options", [])[0]] if question.get("correct_options") else []
+                        elif j == 1:  # Second candidate gets them mostly right
+                            if k % 2 == 0:  # Alternate correct/wrong
+                                answer["options"] = [question.get("correct_options", [])[0]] if question.get("correct_options") else []
+                            else:
+                                # Pick a wrong answer
+                                all_options = [opt["value"] for opt in question.get("options", [])]
+                                correct_options = set(question.get("correct_options", []))
+                                wrong_options = [opt for opt in all_options if opt not in correct_options]
+                                if wrong_options:
+                                    answer["options"] = [wrong_options[0]]
+                                else:
+                                    answer["options"] = [all_options[0]] if all_options else []
+                        else:  # Third candidate gets them right
+                            answer["options"] = [question.get("correct_options", [])[0]] if question.get("correct_options") else []
+                                
+                    elif question["type"] == "choose_many":
+                        # For multiple select questions
+                        if j == 0:  # First candidate gets them wrong
+                            answer["options"] = []
+                        elif j == 1:  # Second candidate gets them partially right
+                            if k % 2 == 0:
+                                answer["options"] = question.get("correct_options", [])
+                            else:
+                                # Mix of correct and incorrect options
+                                all_options = [opt["value"] for opt in question.get("options", [])]
+                                correct_options = set(question.get("correct_options", []))
+                                answer["options"] = list(correct_options)[:1]  # Just one correct option
+                        else:  # Third candidate gets them right
+                            answer["options"] = question.get("correct_options", [])
+                                
+                    elif question["type"] == "text_based":
+                        # For text-based questions, generate more realistic answers based on the question
+                        question_text_lower = question["text"].lower()
+                        
+                        if "python" in question_text_lower:
+                            if "framework" in question_text_lower or "web" in question_text_lower:
+                                answer["text"] = "Python frameworks like Django and Flask are commonly used for web development. Django is a high-level framework that encourages rapid development and clean design."
+                            elif "difference" in question_text_lower or "between" in question_text_lower:
+                                answer["text"] = "The main differences between lists and tuples in Python are mutability. Lists are mutable (can be changed after creation) while tuples are immutable (cannot be changed after creation). Lists use square brackets [] while tuples use parentheses ()."
+                            elif "advantage" in question_text_lower or "benefit" in question_text_lower:
+                                answer["text"] = "One advantage of Python is its readability and simplicity. The syntax is clean and easy to understand, making it great for beginners. It also has a large ecosystem of libraries and frameworks."
+                            else:
+                                answer["text"] = f"Regarding the question '{question['text']}', this is a typical Python concept that involves understanding data structures, syntax, or best practices."
+                        elif "database" in question_text_lower or "sql" in question_text_lower:
+                            answer["text"] = "SQL databases are relational and use structured query language for defining and manipulating data. They're ideal for complex queries and ACID transactions. Common examples include PostgreSQL, MySQL, and SQLite."
+                        elif "api" in question_text_lower:
+                            answer["text"] = "An API (Application Programming Interface) is a set of rules that allows programs to talk to each other. REST APIs use HTTP requests to GET, PUT, POST and DELETE data. They're stateless and cacheable."
+                        else:
+                            answer["text"] = f"This is my response to the question: {question['text']}. It requires understanding of the relevant concepts and applying best practices."
+                    
+                    answers.append(ApplicationAnswer(**answer))
+                
+                # Create the application
+                application_create = ApplicationCreate(
+                    job_id=job.id,
+                    assessment_id=assessment.id,
+                    user_id=user.id,
+                    answers=answers
+                )
+                
+                application = create_application(db, application_create)
+                logger.info(f"Created application for user {user.email} on job '{job.title}' with assessment '{assessment.title}'")
+        
+        logger.info("Database seeding completed successfully!")
+        
+    except Exception as e:
+        logger.error(f"Error during database seeding: {e}")
+        db.rollback()
+        raise
+    finally:
+        db.close()

backend/docker-compose.yml

@@ -22,6 +22,7 @@ services:
       - APP_NAME=AI-Powered Hiring Assessment Platform
       - APP_VERSION=0.1.0
       - APP_DESCRIPTION=MVP for managing hiring assessments using AI
+      - MISTRAL_API_KEY=${MISTRAL_API_KEY}
     networks:
       - app-network
 

backend/docker-entrypoint.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+# Run database seeding
+echo "Running database seeding..."
+python db_seeder.py
+
+# Then exec the container's main process (what's specified as CMD in the Dockerfile)
+exec "$@"

backend/main.py

@@ -5,6 +5,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse
 import logging
+from contextlib import asynccontextmanager
 
 from database.database import engine
 from models import Base
@@ -14,23 +15,38 @@ from api.job_routes import router as job_router
 from api.assessment_routes import router as assessment_router
 from api.application_routes import router as application_router
 from config import settings
+from logging_config import get_logger
+from db_seeder import seed_database
 
-# ----------------------------
-# Logging configuration
-# ----------------------------
+# Create logger for this module
 logging.basicConfig(level=settings.log_level)
 logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
-# ----------------------------
-# Environment variables
-# ----------------------------
 PORT = int(os.environ.get("PORT", 7860))
 HOST = os.environ.get("HOST", "0.0.0.0")
 DEBUG = os.getenv("DEBUG", str(settings.debug)).lower() == "true"
 
-# ----------------------------
-# Initialize FastAPI
-# ----------------------------
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Handle startup and shutdown events"""
+    # Startup
+    logger.info(f"Starting {settings.app_name} v{settings.app_version}")
+    logger.info(f"Database URL: {settings.database_url}")
+        
+    # Seed the database if it's empty
+    logger.info("Checking if database needs seeding...")
+    seed_database()
+    logger.info("Database seeding check completed")
+    
+    logger.info("Application started successfully")
+    
+    yield
+    # Shutdown
+    logger.info("Application shutting down")
+
+# Initialize FastAPI app with settings
 app = FastAPI(
     title=settings.app_name,
     description=settings.app_description,

backend/services/ai_service.py

@@ -2,12 +2,29 @@ import re
 from typing import List, Dict, Any
 from schemas.assessment import AssessmentQuestion
 from schemas.application import ApplicationAnswerWithQuestion
-from integrations.ai_integration.ai_factory import AIGeneratorFactory, DEFAULT_PROVIDER
+from integrations.ai_integration.ai_factory import AIGeneratorFactory, AIProvider, DEFAULT_PROVIDER
 from logging_config import get_logger
+from config import settings
 
 # Create logger for this module
 logger = get_logger(__name__)
 
+def get_current_provider():
+    """Get the current AI provider from settings"""
+    try:
+        provider_value = settings.ai_provider.lower()
+        # Map string values to enum
+        provider_map = {
+            'mock': AIProvider.MOCK,
+            'openai': AIProvider.OPENAI,
+            'anthropic': AIProvider.ANTHROPIC,
+            'google': AIProvider.GOOGLE,
+            'mistral': AIProvider.MISTRAL
+        }
+        return provider_map.get(provider_value, DEFAULT_PROVIDER)
+    except:
+        return DEFAULT_PROVIDER
+
 def generate_questions(title: str, questions_types: List[str], additional_note: str = None, job_info: dict = None, provider=None) -> List[AssessmentQuestion]:
     """
     Generate questions based on the assessment title, job information, and specified question types.
@@ -17,16 +34,16 @@ def generate_questions(title: str, questions_types: List[str], additional_note:
         questions_types: List of question types to generate (choose_one, choose_many, text_based)
         additional_note: Additional information to guide question generation
         job_info: Information about the job the assessment is for
-        provider: The AI provider to use (defaults to the default provider)
+        provider: The AI provider to use (defaults to the provider from settings)
 
     Returns:
         List of generated AssessmentQuestion objects
     """
     logger.info(f"Generating questions for assessment: '{title}' with types: {questions_types}")
 
-    # Use the default provider if none is specified
+    # Use the provider from settings if none is specified
     if provider is None:
-        provider = DEFAULT_PROVIDER
+        provider = get_current_provider()
 
     # Get the AI generator from the factory
     ai_generator = AIGeneratorFactory.create_generator(provider)
@@ -50,7 +67,7 @@ def score_answer(question: AssessmentQuestion, answer_text: str, selected_option
         question: The question being answered
         answer_text: The text of the answer (for text-based questions)
         selected_options: Selected options (for multiple choice questions)
-        provider: The AI provider to use (defaults to the default provider)
+        provider: The AI provider to use (defaults to the provider from settings)
 
     Returns:
         Dictionary containing score information:
@@ -60,11 +77,11 @@ def score_answer(question: AssessmentQuestion, answer_text: str, selected_option
             'correct': bool  # Whether the answer is correct
         }
     """
-    logger.info(f"Scoring answer for question: '{question.text[:50]}...' using {provider.value if provider else DEFAULT_PROVIDER.value} provider")
+    logger.info(f"Scoring answer for question: '{question.text[:50]}...' using {provider.value if provider else get_current_provider().value} provider")
 
-    # Use the default provider if none is specified
+    # Use the provider from settings if none is specified
     if provider is None:
-        provider = DEFAULT_PROVIDER
+        provider = get_current_provider()
 
     # Get the AI generator from the factory
     ai_generator = AIGeneratorFactory.create_generator(provider)
@@ -88,16 +105,16 @@ def estimate_assessment_duration(title: str, job_info: dict, questions: List[Ass
         job_info: Information about the job the assessment is for
         questions: List of questions in the assessment
         additional_note: Additional information about the assessment
-        provider: The AI provider to use (defaults to the default provider)
+        provider: The AI provider to use (defaults to the provider from settings)
 
     Returns:
         Estimated duration in minutes
     """
     logger.info(f"Estimating duration for assessment: '{title}' with {len(questions)} questions")
 
-    # Use the default provider if none is specified
+    # Use the provider from settings if none is specified
     if provider is None:
-        provider = DEFAULT_PROVIDER
+        provider = get_current_provider()
 
     # Get the AI generator from the factory
     ai_generator = AIGeneratorFactory.create_generator(provider)
@@ -142,11 +159,11 @@ especially for senior roles or text-based questions requiring detailed responses
     duration_match = re.search(r'\d+', duration_estimate)
     if duration_match:
         duration_minutes = int(duration_match.group())
-        
+
         # Apply our own logic to ensure minimum duration per question and adjust based on job seniority
         # Calculate base duration (at least 2 minutes per question)
         base_duration = len(questions) * 2
-        
+
         # Adjust based on job seniority
         seniority = job_info.get('seniority', '').lower()
         if seniority in ['senior', 'lead']:
@@ -154,16 +171,16 @@ especially for senior roles or text-based questions requiring detailed responses
         elif seniority in ['mid', 'intermediate']:
             base_duration = int(base_duration * 1.2)  # 20% more time for mid-level roles
         # Junior/intern roles get the base time (2 min per question)
-        
+
         # Adjust based on question complexity (text-based questions take more time)
         text_questions = sum(1 for q in questions if q.type == 'text_based')
         if text_questions > 0:
             # Add extra time for text-based questions (they typically take longer)
             base_duration += text_questions * 2  # Additional 2 minutes per text question
-        
+
         # Take the maximum of AI estimation and our calculated minimum
         duration_minutes = max(duration_minutes, base_duration)
-        
+
         # Ensure the duration is within reasonable bounds (5-180 minutes)
         duration_minutes = max(5, min(180, duration_minutes))
         logger.info(f"Estimated duration for assessment '{title}': {duration_minutes} minutes (AI: {int(duration_match.group())}, calculated min: {base_duration})")
@@ -172,21 +189,21 @@ especially for senior roles or text-based questions requiring detailed responses
         # If no number is found in the response, return a default duration based on question count
         # Calculate base duration (at least 2 minutes per question)
         base_duration = len(questions) * 2
-        
+
         # Adjust based on job seniority
         seniority = job_info.get('seniority', '').lower()
         if seniority in ['senior', 'lead']:
             base_duration = int(base_duration * 1.5)  # 50% more time for senior roles
         elif seniority in ['mid', 'intermediate']:
             base_duration = int(base_duration * 1.2)  # 20% more time for mid-level roles
-        
+
         # Adjust based on question complexity (text-based questions take more time)
         text_questions = sum(1 for q in questions if q.type == 'text_based')
         if text_questions > 0:
             base_duration += text_questions * 2  # Additional 2 minutes per text question
-        
+
         # Ensure minimum duration is at least 5 minutes
         default_duration = max(5, base_duration)
-        
+
         logger.warning(f"No duration found in AI response. Using calculated default: {default_duration} minutes")
         return default_duration