Merge branch 'master'

backend/QWEN.md

@@ -10,6 +10,7 @@ The application follows a clean architecture with proper separation of concerns:
 - **Database Layer**: Manages database connections and sessions
 - **Model Layer**: Defines database models using SQLAlchemy
 - **Schema Layer**: Defines Pydantic schemas for request/response validation
+- **Integration Layer**: Handles external services like AI providers
 
 ## Technologies Used
 
@@ -20,6 +21,9 @@ The application follows a clean architecture with proper separation of concerns:
 - **Alembic**: Database migration tool
 - **Pydantic**: Data validation and settings management
 - **UUID**: For generating unique identifiers
+- **Mistral AI**: AI provider for generating questions and scoring answers
+- **JWT**: For authentication and authorization
+- **bcrypt**: For password hashing
 
 ## Architecture Components
 
@@ -34,6 +38,8 @@ backend/
 │   └── routes.py        # Root and health check endpoints
 ├── database/            # Database connection utilities
 │   └── database.py      # Database engine and session management
+├── integrations/        # External service integrations
+│   └── ai_integration/  # AI provider implementations
 ├── models/              # SQLAlchemy models
 │   ├── user.py          # User model
 │   ├── job.py           # Job model
@@ -45,13 +51,17 @@ backend/
 │   ├── job.py           # Job schemas
 │   ├── assessment.py    # Assessment schemas
 │   ├── application.py   # Application schemas
+│   ├── enums.py         # Enum definitions
 │   └── base.py          # Base schema class
 ├── services/            # Business logic layer
 │   ├── user_service.py  # User-related services
 │   ├── job_service.py   # Job-related services
 │   ├── assessment_service.py # Assessment-related services
 │   ├── application_service.py # Application-related services
+│   ├── ai_service.py    # AI-related services
 │   └── base_service.py  # Generic service functions
+├── utils/               # Utility functions
+│   └── dependencies.py  # Dependency injection functions
 ├── alembic/             # Database migration files
 ├── config.py            # Application configuration
 ├── logging_config.py    # Logging configuration
@@ -63,21 +73,31 @@ backend/
 ### Key Features
 
 1. **User Management**:
-   - Registration and authentication
-   - Role-based access (HR vs Applicant)
+   - Registration and authentication with role-based access (HR vs Applicant)
+   - JWT-based secure session management
+   - Password hashing using bcrypt
 
 2. **Job Management**:
    - Create, update, delete job postings
    - Manage job details and requirements
+   - Track applicant counts
 
-3. **Assessment Management**:
-   - Create assessments linked to jobs
-   - Define questions and passing scores
-   - Regenerate assessments with new questions
+3. **AI-Powered Assessment Management**:
+   - Create assessments with AI-generated questions based on job requirements
+   - Define question types (multiple choice single answer, multiple choice multiple answers, text-based)
+   - Regenerate assessments with new AI-generated questions
+   - Automatic duration estimation based on content using AI
+   - Passing score configuration (range 20-80)
 
 4. **Application Management**:
    - Submit applications with answers
+   - AI-powered scoring of text-based answers with rationales
    - Track application results and scores
+   - Detailed feedback with AI-generated rationales
+
+5. **Dashboard Features**:
+   - View application scores with sorting options
+   - Monitor assessment performance
 
 ### API Endpoints
 
@@ -99,14 +119,20 @@ backend/
 #### Assessments
 - `GET /assessments/jobs/{jid}` - List assessments for a job
 - `GET /assessments/jobs/{jid}/{aid}` - Get assessment details
-- `POST /assessments/jobs/{id}` - Create assessment
-- `PATCH /assessments/jobs/{jid}/{aid}/regenerate` - Regenerate assessment
+- `POST /assessments/jobs/{id}` - Create assessment with AI-generated questions
+- `PATCH /assessments/jobs/{jid}/{aid}/regenerate` - Regenerate assessment with new AI-generated questions
 - `PATCH /assessments/jobs/{jid}/{aid}` - Update assessment
 - `DELETE /assessments/jobs/{jid}/{aid}` - Delete assessment
 
 #### Applications
-- `GET /applications/jobs/{jid}/assessments/{aid}` - List applications
+- `GET /applications/jobs/{jid}/assessments/{aid}` - List applications for an assessment
+- `GET /applications/jobs/{jid}/assessment_id/{aid}/applications/{id}` - Get detailed application
 - `POST /applications/jobs/{jid}/assessments/{aid}` - Create application
+- `GET /applications/my-applications` - Get current user's applications
+- `GET /applications/my-applications/{id}` - Get specific application for current user
+
+#### Dashboard
+- `GET /dashboard/applications/scores` - Get application scores with sorting options
 
 #### Health Check
 - `GET /` - Root endpoint
@@ -130,11 +156,14 @@ LOG_LEVEL=INFO
 LOG_FILE=app.log
 LOG_FORMAT=%(asctime)s - %(name)s - %(levelname)s - %(message)s
 
-# JWT Configuration (for future use)
+# JWT Configuration
 SECRET_KEY=your-secret-key-here
 ALGORITHM=HS256
 ACCESS_TOKEN_EXPIRE_MINUTES=30
 
+# AI Provider Configuration
+MISTRAL_API_KEY=your-mistral-api-key-here
+
 # Application Configuration
 APP_NAME=AI-Powered Hiring Assessment Platform
 APP_VERSION=0.1.0
@@ -146,6 +175,7 @@ APP_DESCRIPTION=MVP for managing hiring assessments using AI
 ### Prerequisites
 - Python 3.11+
 - pip package manager
+- Mistral AI API key (optional, for AI features)
 
 ### Setup Instructions
 
@@ -153,7 +183,7 @@ APP_DESCRIPTION=MVP for managing hiring assessments using AI
    ```bash
    pip install -r requirements.txt
    ```
-   
+
 2. **Set Up Environment Variables**:
    Copy the `.env.example` file to `.env` and adjust the values as needed.
 
@@ -166,7 +196,7 @@ APP_DESCRIPTION=MVP for managing hiring assessments using AI
    ```bash
    python main.py
    ```
-   
+
    Or using uvicorn directly:
    ```bash
    uvicorn main:app --host 0.0.0.0 --port 8000 --reload
@@ -180,9 +210,9 @@ uvicorn main:app --reload --host 0.0.0.0 --port 8000
 
 ## Testing
 
-To run tests (when available):
+To run tests:
 ```bash
-pytest
+python -m pytest
 ```
 
 ## Logging
@@ -213,28 +243,56 @@ The application uses Alembic for database migrations:
    - Log errors appropriately
 
 3. **Security**:
-   - Passwords should be hashed (currently using placeholder)
+   - Passwords are hashed using bcrypt
    - Input validation through Pydantic schemas
    - SQL injection prevention through SQLAlchemy ORM
+   - JWT-based authentication and authorization
 
 4. **Architecture**:
    - Keep business logic in service layer
    - Use dependency injection for database sessions
    - Separate API routes by domain/model
    - Maintain clear separation between layers
+   - Use enums for fixed values to ensure consistency
+
+5. **AI Integration**:
+   - Abstract AI provider implementations behind interfaces
+   - Use factory pattern for AI provider selection
+   - Implement fallback mechanisms for AI services
+
+## Implemented Features
+
+- ✅ JWT token-based authentication
+- ✅ Password hashing implementation using bcrypt
+- ✅ AI-powered question generation based on job requirements
+- ✅ AI-powered scoring of text-based answers with rationales
+- ✅ Assessment duration estimation using AI
+- ✅ Comprehensive API input/output validation with Pydantic schemas
+- ✅ Proper enum definitions for consistent API contracts
+- ✅ Role-based access control (HR vs Applicant)
+- ✅ Detailed application feedback with AI-generated rationales
+- ✅ My Applications endpoint for candidates to track their submissions
+- ✅ Dashboard endpoints for viewing application scores
+- ✅ Assessment regeneration functionality
+- ✅ Proper handling of answers as JSON data within applications
+- ✅ Comprehensive logging throughout the application
 
 ## Future Enhancements
 
-- JWT token-based authentication
-- Password hashing implementation
-- Advanced assessment features
-- Admin dashboard endpoints
-- More sophisticated logging and monitoring
-- Unit and integration tests
-
-# TODO:
-- when creating an assessment we should pass the questions of the assessment. 
-- all APIs input and output should have a cleare schema, even the enums should be clear and apear in the swagger apis (when visiting /docs)
-- the validation of the inputs should be done by pydantic and in the model level, not in the model level only! 
-- the answers is not a model itself, so the services/answer functions should be aware of that. 
+- Enhanced AI scoring with more sophisticated models
+- Advanced analytics and reporting features
+- More sophisticated assessment types
+- Integration with additional AI providers
+- Performance optimizations for large datasets
+- Unit and integration tests coverage
+- Enhanced error handling and retry mechanisms
+- Rate limiting for API endpoints
+- Audit logging for compliance requirements
+
+## Completed TODO Items
+
+- ✅ When creating an assessment, questions are now generated using AI based on job requirements and specified question types
+- ✅ All APIs now have clear input/output schemas with enums properly defined and visible in Swagger documentation
+- ✅ Input validation is now done at both the Pydantic schema level and model level
+- ✅ Answers are properly handled as part of the application model rather than as a separate model
 

backend/alembic/versions/290ee4ce077e_add_score_and_question_scores_columns_.py

@@ -0,0 +1,34 @@
+"""Add score and question_scores columns to applications table
+
+Revision ID: 290ee4ce077e
+Revises: f9f1aa7380ab
+Create Date: 2026-02-09 11:29:38.655897
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '290ee4ce077e'
+down_revision: Union[str, Sequence[str], None] = 'f9f1aa7380ab'
+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! ###
+    op.add_column('applications', sa.Column('score', sa.Float(), nullable=True))
+    op.add_column('applications', sa.Column('question_scores', sa.Text(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('applications', 'question_scores')
+    op.drop_column('applications', 'score')
+    # ### end Alembic commands ###

backend/api/application_routes.py

@@ -53,6 +53,15 @@ def get_applications_list(jid: str, aid: str, page: int = 1, limit: int = 10, db
         from services.user_service import get_user
         user = get_user(db, application.user_id)
 
+        # Parse question scores from JSON string
+        question_scores = []
+        if application.question_scores:
+            try:
+                question_scores = json.loads(application.question_scores)
+            except json.JSONDecodeError:
+                logger.warning(f"Failed to parse question scores for application ID: {application.id}")
+                question_scores = []
+
         # Create response object that matches technical requirements exactly
         application_response = {
             'id': application.id,
@@ -62,6 +71,7 @@ def get_applications_list(jid: str, aid: str, page: int = 1, limit: int = 10, db
             'answers': [],  # Not including answers in the list view for performance
             'score': score,
             'passing_score': assessment.passing_score,
+            'question_scores': question_scores,  # Include individual question scores
             'assessment_details': {
                 'id': assessment.id,
                 'title': assessment.title,
@@ -202,6 +212,15 @@ def get_application_detail(jid: str, aid: str, id: str, db: Session = Depends(ge
             logger.error(f"Error creating assessment details: {str(e)}")
             assessment_details_obj = None
 
+    # Parse question scores from JSON string
+    question_scores = []
+    if application.question_scores:
+        try:
+            question_scores = json.loads(application.question_scores)
+        except json.JSONDecodeError:
+            logger.warning(f"Failed to parse question scores for application ID: {application.id}")
+            question_scores = []
+
     application_detail = ApplicationDetailedResponse(
         id=application.id,
         job_id=application.job_id,
@@ -210,6 +229,7 @@ def get_application_detail(jid: str, aid: str, id: str, db: Session = Depends(ge
         answers=enriched_answers,
         score=score,
         passing_score=assessment.passing_score,
+        question_scores=question_scores,  # Include individual question scores
         assessment_details=assessment_details_obj,
         user={
             'id': user.id if user else None,
@@ -416,6 +436,15 @@ def get_my_application(id: str, db: Session = Depends(get_db), current_user: Use
             logger.error(f"Error creating assessment details: {str(e)}")
             assessment_details_obj = None
 
+    # Parse question scores from JSON string
+    question_scores = []
+    if application.question_scores:
+        try:
+            question_scores = json.loads(application.question_scores)
+        except json.JSONDecodeError:
+            logger.warning(f"Failed to parse question scores for application ID: {application.id}")
+            question_scores = []
+
     application_detail = ApplicationDetailedResponse(
         id=application.id,
         job_id=application.job_id,
@@ -424,6 +453,7 @@ def get_my_application(id: str, db: Session = Depends(get_db), current_user: Use
         answers=enriched_answers,
         score=score,
         passing_score=assessment.passing_score,
+        question_scores=question_scores,  # Include individual question scores
         assessment_details=assessment_details_obj,
         user={
             'id': user.id if user else None,

backend/integrations/ai_integration/mistral_generator.py

@@ -193,18 +193,42 @@ Job Information:
         if additional_note:
             job_details += f"- Additional Note: {additional_note}\n"
 
+        # Determine the recommended number of questions based on job complexity
+        if job_info:
+            # Adjust the number of questions based on job seniority and skills
+            seniority = job_info.get('seniority', '').lower()
+            skill_count = len(job_info.get('skill_categories', []))
+            
+            # Base number of questions based on complexity
+            if seniority in ['senior', 'lead']:
+                base_questions = 15  # More questions for senior roles
+            elif seniority in ['mid', 'intermediate']:
+                base_questions = 12
+            else:  # intern, junior
+                base_questions = 10
+            
+            # Adjust based on number of skills to cover
+            adjusted_questions = base_questions + (skill_count // 2)
+            
+            # Ensure we have at least one of each requested type if specified
+            min_questions = len(questions_types)  # At least one per type requested
+            total_questions = max(adjusted_questions, min_questions)
+        else:
+            # Default if no job info is provided
+            total_questions = max(10, len(questions_types))  # At least 10 or requested types count
+
         prompt = f"""
 You are an assessment generator.
 
-Generate EXACTLY {len(questions_types)} questions for the following job.
+Generate approximately {total_questions} questions for the following job. The number of questions should be appropriate for the job complexity and seniority level.
 
 {job_details}
 
 MANDATORY RULES:
-1. Output MUST be a JSON ARRAY with EXACTLY {len(questions_types)} objects.
-2. The list MUST contain:
-   - {mcq_count} MCQ questions (multiple choice)
-   - {text_count} TEXT questions (text-based)
+1. Output MUST be a JSON ARRAY with approximately {total_questions} objects.
+2. Distribute the questions among the requested types proportionally:
+   - Include MCQ questions (multiple choice) - both single and multiple answer types
+   - Include TEXT questions (text-based)
 3. Do NOT include explanations or markdown.
 4. Follow the schema EXACTLY.
 
@@ -223,6 +247,12 @@ Rules per type:
 - MCQ → 4 choices + correct_answer as the text of the correct choice
 - TEXT → correct_answer = null
 
+Consider the following when generating questions:
+- For senior positions, include more complex and scenario-based questions
+- For junior positions, focus on fundamental concepts
+- Ensure questions cover the skill categories mentioned in the job description
+- Mix difficulty levels appropriately for the role
+
 Return ONLY the JSON array.
 """
 
@@ -240,8 +270,9 @@ Return ONLY the JSON array.
 
             # Determine the question type based on the response
             if q_data.get("type") == "MCQ":
-                # For multiple choice questions
-                question_type = QuestionType.choose_one  # Default to choose_one
+                # For multiple choice questions, determine if it's single or multiple choice
+                # For now, default to choose_one, but we could enhance this logic later
+                question_type = QuestionType.choose_one
 
                 # Create options
                 options = []
@@ -249,7 +280,7 @@ Return ONLY the JSON array.
                     option = AssessmentQuestionOption(text=choice, value=choice)
                     options.append(option)
 
-                # Find the correct option
+                # Find the correct option(s)
                 correct_options = []
                 correct_answer = q_data.get("correct_answer")
                 if correct_answer:

backend/integrations/ai_integration/mock_ai_generator.py

@@ -13,39 +13,65 @@ class MockAIGenerator(AIGeneratorInterface):
     """
     
     def generate_questions(
-        self, 
-        title: str, 
-        questions_types: List[str], 
-        additional_note: str = None, 
+        self,
+        title: str,
+        questions_types: List[str],
+        additional_note: str = None,
         job_info: Dict[str, Any] = None
     ) -> List[AssessmentQuestion]:
         """
         Generate questions using mock AI logic based on job information.
         """
-        num_questions = len(questions_types)
+        # Determine the recommended number of questions based on job complexity
+        if job_info:
+            # Adjust the number of questions based on job seniority and skills
+            seniority = job_info.get('seniority', '').lower()
+            skill_count = len(job_info.get('skill_categories', []))
+            
+            # Base number of questions based on complexity
+            if seniority in ['senior', 'lead']:
+                base_questions = 15  # More questions for senior roles
+            elif seniority in ['mid', 'intermediate']:
+                base_questions = 12
+            else:  # intern, junior
+                base_questions = 10
+            
+            # Adjust based on number of skills to cover
+            adjusted_questions = base_questions + (skill_count // 2)
+            
+            # Ensure we have at least one of each requested type if specified
+            min_questions = len(questions_types)  # At least one per type requested
+            total_questions = max(adjusted_questions, min_questions)
+        else:
+            # Default if no job info is provided
+            total_questions = max(10, len(questions_types))  # At least 10 or requested types count
+
         generated_questions = []
-        
-        for i, q_type in enumerate(questions_types):
+
+        for i in range(total_questions):
+            # Cycle through the requested question types to ensure variety
+            q_type = questions_types[i % len(questions_types)]
+
             # Create a question ID
             question_id = str(uuid.uuid4())
-            
+
             # Generate question text based on the assessment title, job info and question type
             question_text = self._generate_question_text(title, q_type, i+1, additional_note, job_info)
-            
+
             # Determine weight (random between 1-5)
             weight = random.randint(1, 5)
-            
+
             # Generate skill categories based on the assessment title and job info
             skill_categories = self._generate_skill_categories(title, job_info)
-            
+
             # Generate options and correct options based on the question type
             options = []
             correct_options = []
-            
+
             if q_type in [QuestionType.choose_one.value, QuestionType.choose_many.value]:
                 options = self._generate_multiple_choice_options(q_type, question_text)
                 correct_options = self._select_correct_options(options, q_type)
-            
+
             # Create the AssessmentQuestion object
             question = AssessmentQuestion(
                 id=question_id,
@@ -56,9 +82,9 @@ class MockAIGenerator(AIGeneratorInterface):
                 options=options,
                 correct_options=correct_options
             )
-            
+
             generated_questions.append(question)
-        
+
         return generated_questions
 
     def _generate_question_text(self, title: str, q_type: str, question_number: int, additional_note: str = None, job_info: Dict[str, Any] = None) -> str:
@@ -390,17 +416,40 @@ class MockAIGenerator(AIGeneratorInterface):
         Returns:
             String response from the AI containing the estimated duration
         """
-        # For the mock implementation, we'll return a simple response with a number
-        # based on the length of the prompt and keywords
+        # For the mock implementation, we'll return a response with a number
+        # based on the length of the prompt and keywords, following the same logic as the AI service
         import random
-        
+        import re
+
+        # Extract information from the prompt to determine duration
         # Count the number of questions mentioned in the prompt
         question_count = prompt.count("Question ")  # Count occurrences of "Question "
         
-        # Estimate duration based on question count (3 minutes per question, with some randomness)
-        estimated_minutes = max(5, question_count * 3 + random.randint(-2, 5))
+        # Extract seniority level from the prompt
+        seniority_match = re.search(r'- Seniority: (\w+)', prompt)
+        seniority = seniority_match.group(1).lower() if seniority_match else 'junior'
+        
+        # Count text-based questions mentioned in the prompt
+        text_questions = prompt.count("(Text-based question requiring written response)")
+        
+        # Calculate base duration (at least 2 minutes per question)
+        base_duration = question_count * 2
+        
+        # Adjust based on job seniority
+        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
+        # Junior/intern roles get the base time (2 min per question)
         
+        # Adjust based on question complexity (text-based questions take more time)
+        if text_questions > 0:
+            base_duration += text_questions * 2  # Additional 2 minutes per text question
+        
+        # Add some randomness to simulate realistic variations
+        estimated_minutes = max(5, base_duration + random.randint(-1, 3))
+
         # Ensure it's within reasonable bounds
         estimated_minutes = min(180, max(5, estimated_minutes))
-        
+
         return f"{estimated_minutes} minutes"

backend/models/application.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, String, Text, ForeignKey, DateTime
+from sqlalchemy import Column, String, Text, ForeignKey, DateTime, Float
 from sqlalchemy.sql import func
 from .base import Base
 import uuid
@@ -11,5 +11,7 @@ class Application(Base):
     assessment_id = Column(String, ForeignKey("assessments.id"), nullable=False)
     user_id = Column(String, ForeignKey("users.id"), nullable=False)
     answers = Column(Text)  # Stored as JSON string
+    score = Column(Float)  # Overall application score
+    question_scores = Column(Text)  # Individual question scores stored as JSON string
     created_at = Column(DateTime(timezone=True), server_default=func.now())
     updated_at = Column(DateTime(timezone=True), onupdate=func.now())

backend/schemas/application.py

@@ -23,6 +23,11 @@ class ApplicationQuestion(BaseModel):
     options: Optional[List[dict]] = []  # Using dict for simplicity
     correct_options: Optional[List[str]] = []
 
+class ApplicationAnswerScore(BaseModel):
+    question_id: str
+    score: float  # Score between 0 and 1
+    rationale: str
+
 class ApplicationAnswerWithQuestion(ApplicationAnswer):
     question_text: str = Field(..., min_length=1, max_length=1000)
     weight: int = Field(..., ge=1, le=5)  # range 1-5
@@ -31,6 +36,7 @@ class ApplicationAnswerWithQuestion(ApplicationAnswer):
     question_options: Optional[List[dict]] = []  # Options for the question
     correct_options: Optional[List[str]] = []
     rationale: str = Field(..., min_length=1, max_length=1000)
+    score: Optional[float] = None  # Score for this specific answer
 
 class ApplicationBase(BaseSchema):
     job_id: str = Field(..., min_length=1)
@@ -52,9 +58,10 @@ class ApplicationAssessment(BaseModel):
 
 class ApplicationResponse(ApplicationBase):
     id: str
-    score: Optional[float] = None
+    score: Optional[float] = None  # Overall application score
     passing_score: Optional[float] = None
     assessment_details: Optional[ApplicationAssessment] = None
+    question_scores: Optional[List[ApplicationAnswerScore]] = None  # Individual question scores
 
     class Config:
         from_attributes = True

backend/services/ai_service.py

@@ -106,15 +106,15 @@ def estimate_assessment_duration(title: str, job_info: dict, questions: List[Ass
     prompt = f"""
     Based on the following assessment details, estimate how many minutes a candidate would need to complete this assessment.
     Consider the complexity of the questions and the job requirements.
-    
+
     Assessment Title: {title}
-    
+
     Job Information:
     - Title: {job_info.get('title', 'N/A')}
     - Seniority: {job_info.get('seniority', 'N/A')}
     - Description: {job_info.get('description', 'N/A')}
     - Skill Categories: {', '.join(job_info.get('skill_categories', []))}
-    
+
     Questions Count: {len(questions)}
     """
 
@@ -129,7 +129,11 @@ def estimate_assessment_duration(title: str, job_info: dict, questions: List[Ass
     if additional_note:
         prompt += f"\nAdditional Notes: {additional_note}"
 
-    prompt += "\n\nPlease provide only a number representing the estimated duration in minutes."
+    prompt += """
+\n\nPlease provide only a number representing the estimated duration in minutes.
+Consider that each question should take at least 2 minutes to answer, with additional time for complex questions,
+especially for senior roles or text-based questions requiring detailed responses.
+"""
 
     # Get the AI's estimation
     duration_estimate = ai_generator.estimate_duration(prompt)
@@ -138,12 +142,51 @@ def estimate_assessment_duration(title: str, job_info: dict, questions: List[Ass
     duration_match = re.search(r'\d+', duration_estimate)
     if duration_match:
         duration_minutes = int(duration_match.group())
-        # Ensure the duration is within reasonable bounds (1-180 minutes)
-        duration_minutes = max(1, min(180, duration_minutes))
-        logger.info(f"Estimated duration for assessment '{title}': {duration_minutes} minutes")
+        
+        # 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']:
+            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
+        # 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})")
         return duration_minutes
     else:
         # If no number is found in the response, return a default duration based on question count
-        default_duration = min(60, max(5, len(questions) * 3))  # 3 minutes per question, capped at 60
-        logger.warning(f"No duration found in AI response. Using default: {default_duration} minutes")
+        # 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

backend/services/application_service.py

@@ -51,19 +51,25 @@ def get_applications_by_user(db: Session, user_id: str, skip: int = 0, limit: in
     return applications
 
 def create_application(db: Session, application: ApplicationCreate) -> Application:
-    """Create a new application"""
+    """Create a new application and calculate scores"""
     logger.info(f"Creating new application for job ID: {application.job_id}, assessment ID: {application.assessment_id}, user ID: {application.user_id}")
+    
+    # Calculate scores for the application
+    score, question_scores = calculate_detailed_application_score(db, application)
+    
     db_application = Application(
         id=str(uuid.uuid4()),
         job_id=application.job_id,
         assessment_id=application.assessment_id,
         user_id=application.user_id,
-        answers=json.dumps([ans.dict() for ans in application.answers])  # Store as JSON string
+        answers=json.dumps([ans.dict() for ans in application.answers]),  # Store as JSON string
+        score=score,  # Store the overall application score
+        question_scores=json.dumps([qs.dict() for qs in question_scores])  # Store individual question scores as JSON
     )
     db.add(db_application)
     db.commit()
     db.refresh(db_application)
-    logger.info(f"Successfully created application with ID: {db_application.id}")
+    logger.info(f"Successfully created application with ID: {db_application.id} and overall score: {score}")
     return db_application
 
 def update_application(db: Session, application_id: str, **kwargs) -> Optional[Application]:
@@ -95,6 +101,106 @@ def delete_application(db: Session, application_id: str) -> bool:
     logger.warning(f"Failed to delete application - application not found: {application_id}")
     return False
 
+def calculate_detailed_application_score(db: Session, application_create: ApplicationCreate):
+    """Calculate detailed scores for an application including individual question scores"""
+    from models.assessment import Assessment
+    from schemas.application import ApplicationAnswerScore
+    
+    logger.debug(f"Calculating detailed scores for application - job ID: {application_create.job_id}, assessment ID: {application_create.assessment_id}")
+    
+    # Get the associated assessment to compare answers with correct answers
+    assessment = db.query(Assessment).filter(Assessment.id == application_create.assessment_id).first()
+    if not assessment:
+        logger.warning(f"Assessment not found for ID: {application_create.assessment_id}")
+        return 0.0, []
+
+    # Parse the questions
+    import json
+    try:
+        questions = json.loads(assessment.questions) if assessment.questions else []
+    except json.JSONDecodeError:
+        logger.error(f"Failed to parse questions for assessment ID: {application_create.assessment_id}")
+        return 0.0, []
+
+    # Create a mapping of question_id to question for easy lookup
+    question_map = {q['id']: q for q in questions}
+
+    # Calculate the scores
+    total_points = 0
+    earned_points = 0
+    question_scores = []
+
+    for answer in application_create.answers:
+        question_id = answer.question_id
+        if not question_id or question_id not in question_map:
+            continue
+
+        question_data = question_map[question_id]
+
+        # Calculate weighted score
+        question_weight = question_data.get('weight', 1)  # Default weight is 1
+        total_points += question_weight
+
+        # Initialize question score object
+        question_score_obj = ApplicationAnswerScore(
+            question_id=question_id,
+            score=0.0,
+            rationale="No rationale available"
+        )
+
+        # For multiple choice questions, score directly without AI
+        if question_data['type'] in ['choose_one', 'choose_many']:
+            correct_options = set(question_data.get('correct_options', []))
+            selected_options = set(answer.options or [])
+
+            # Check if the selected options match the correct options exactly
+            if selected_options == correct_options:
+                earned_points += question_weight  # Full points for correct answer
+                question_score_obj.score = 1.0  # Perfect score
+                question_score_obj.rationale = "Correct answer"
+            else:
+                question_score_obj.score = 0.0  # No points for incorrect answer
+                question_score_obj.rationale = f"Incorrect. Correct options: {list(correct_options)}, Selected: {list(selected_options)}"
+
+        # For text-based questions, use AI to evaluate the answer
+        elif question_data['type'] == 'text_based':
+            # Convert the question data to an AssessmentQuestion object
+            from schemas.assessment import AssessmentQuestion, AssessmentQuestionOption
+            from schemas.enums import QuestionType
+            question_obj = AssessmentQuestion(
+                id=question_data['id'],
+                text=question_data['text'],
+                weight=question_data['weight'],
+                skill_categories=question_data['skill_categories'],
+                type=QuestionType(question_data['type']),
+                options=[AssessmentQuestionOption(text=opt['text'], value=opt['value']) for opt in question_data.get('options', [])],
+                correct_options=question_data.get('correct_options', [])
+            )
+
+            # Use AI service to score the text-based answer
+            from services.ai_service import score_answer
+            score_result = score_answer(
+                question=question_obj,
+                answer_text=answer.text or '',
+                selected_options=answer.options or []
+            )
+
+            earned_points += score_result['score'] * question_weight
+            question_score_obj.score = score_result['score']
+            question_score_obj.rationale = score_result['rationale']
+
+        question_scores.append(question_score_obj)
+
+    # Calculate percentage score
+    if total_points > 0:
+        overall_score = (earned_points / total_points) * 100
+    else:
+        overall_score = 0.0
+
+    logger.debug(f"Calculated detailed scores: overall {overall_score}% ({earned_points}/{total_points} points), {len(question_scores)} questions scored")
+    return round(overall_score, 2), question_scores
+
+
 def calculate_application_score(db: Session, application_id: str) -> float:
     """Calculate the score for an application"""
     logger.debug(f"Calculating score for application ID: {application_id}")