initial commit

backend/.env.example

@@ -0,0 +1,34 @@
+# Database Configuration
+DATABASE_URL=sqlite:///./assessment_platform.db
+
+# Server Configuration
+HOST=0.0.0.0
+PORT=8000
+DEBUG=False
+
+# Logging Configuration
+LOG_LEVEL=INFO
+LOG_FILE=app.log
+LOG_FORMAT=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+
+# JWT Configuration (for future use)
+SECRET_KEY=your-secret-key-here
+ALGORITHM=HS256
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+
+# Application Configuration
+APP_NAME=AI-Powered Hiring Assessment Platform
+APP_VERSION=0.1.0
+APP_DESCRIPTION=MVP for managing hiring assessments using AI
+
+# AI Provider Configuration (for future use)
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+GOOGLE_AI_API_KEY=
+
+# Email Configuration (for future use)
+SMTP_SERVER=
+SMTP_PORT=
+SMTP_USERNAME=
+SMTP_PASSWORD=
+FROM_EMAIL=

backend/.gitignore

@@ -0,0 +1,307 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation docs/
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+desktop.ini
+
+# Database
+*.db
+*.db-journal
+
+# Local SQLite database
+assessment_platform.db
+test_assessment_platform.db
+
+# Environment variables
+.env
+
+# Logs
+logs/
+*.log
+
+# Coverage
+.coverage*
+htmlcov/
+
+# Pytest
+.pytest_cache/
+__pycache__/
+
+# Alembic
+alembic/versions/*.pyc
+
+# FastAPI docs
+docs/
+
+# Temporary files
+*.tmp
+*.temp
+
+# Python virtual environments (specific to this project)
+.venv/
+venv/
+
+# Local config files
+config_local.py
+local_settings.py
+
+# Sensitive files
+secrets.json
+credentials.json
+*.pem
+*.key
+*.crt
+*.cert
+
+# Cache directories
+__pycache__/
+*.pyc
+*$py.class
+*.so
+.Python
+jinja2/
+webassets/
+.sass-cache
+
+# IDE specific files
+.vscode/
+.idea/
+*.tmproj
+*.sublime-project
+*.sublime-workspace
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.cov/
+.coverage.*
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon?
+**/.DS_Store
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Windows
+[Ee]xpress
+[Dd]esktop.ini
+$RECYCLE.BIN/
+*.cab
+*.msi
+*.msix
+*.msc
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+*.lnk
+
+# Python
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# FastAPI / Uvicorn
+uvicorn_error.log
+uvicorn_access.log
+
+# Docker
+.dockerignore
+.docker/
+
+# Docker compose
+.docker-compose.override.yml
+.docker-compose.yml
+
+# Local development settings
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Application logs
+app.log
+*.log
+
+# Database migrations backup
+alembic/versions/*.bak
+
+# Coverage reports
+.coverage.xml
+.coveralls.yml
+coverage/lcov-report/
+
+# IDE
+.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.idea/*
+!.idea/codeStyles/Project.xml
+.vs/
+*.sw*
+*~
+.project
+.pydevproject
+*.kate-swp
+
+# Python REPL history
+.python_history
+
+# Coverage
+.coverage*

backend/DOCKER_README.md

@@ -0,0 +1,94 @@
+# AI-Powered Hiring Assessment Platform - Docker Setup
+
+This guide explains how to build and run the AI-Powered Hiring Assessment Platform using Docker.
+
+## Prerequisites
+
+- Docker installed on your machine
+- Docker Compose installed (usually comes with Docker Desktop)
+
+## Building and Running the Application
+
+### 1. Clone the Repository
+
+```bash
+git clone <repository-url>
+cd backend
+```
+
+### 2. Build and Run with Docker Compose
+
+The easiest way to run the application is using Docker Compose:
+
+```bash
+docker-compose up --build
+```
+
+This command will:
+- Build the backend image
+- Start the backend service
+- Expose the application on port 8000
+
+### 3. Access the Application
+
+Once the containers are running, you can access the application at:
+- API Documentation: http://localhost:8000/docs
+- Health Check: http://localhost:8000/health
+
+### 4. Alternative: Build and Run Individual Containers
+
+If you prefer to build and run individual containers:
+
+#### Build the Image
+```bash
+docker build -t assessment-platform-backend .
+```
+
+#### Run the Container
+```bash
+docker run -p 8000:8000 assessment-platform-backend
+```
+
+## Environment Variables
+
+The application uses the following environment variables (defined in docker-compose.yml):
+
+- `DATABASE_URL`: Database connection string (defaults to SQLite)
+- `HOST`: Host address (defaults to 0.0.0.0)
+- `PORT`: Port number (defaults to 8000)
+- `DEBUG`: Debug mode (defaults to True)
+- `LOG_LEVEL`: Logging level (defaults to INFO)
+- `LOG_FILE`: Log file path (defaults to app.log)
+- `SECRET_KEY`: Secret key for JWT tokens
+- `ALGORITHM`: Algorithm for JWT encoding
+- `ACCESS_TOKEN_EXPIRE_MINUTES`: Token expiration time
+- `APP_NAME`: Application name
+- `APP_VERSION`: Application version
+- `APP_DESCRIPTION`: Application description
+
+## Stopping the Application
+
+To stop the application:
+
+```bash
+# If running with docker-compose
+Ctrl+C in the terminal where it's running
+
+# Or in another terminal
+docker-compose down
+```
+
+## Troubleshooting
+
+1. **Port Already in Use**: If port 8000 is already in use, change the port mapping in docker-compose.yml
+
+2. **Permission Issues**: Make sure you have the necessary permissions to run Docker commands
+
+3. **Build Errors**: Check that all dependencies in requirements.txt are compatible with the Python version
+
+## Development Notes
+
+- The current setup uses SQLite as the database for simplicity
+- For production deployments, consider using PostgreSQL or MySQL
+- The volume mount in docker-compose.yml allows for live reloading during development
+- Logs are stored in the ./logs directory on the host machine

backend/Dockerfile

@@ -0,0 +1,32 @@
+# Use official Python runtime as the base image
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        build-essential \
+        gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy the requirements file first to leverage Docker cache
+COPY requirements*.txt ./
+
+# Install Python dependencies
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt
+
+# Copy the rest of the application code
+COPY . .
+
+# Expose the port the app runs on
+EXPOSE 8000
+
+# Run the application
+CMD ["python", "main.py"]

backend/QWEN.md

@@ -0,0 +1,240 @@
+# AI-Powered Hiring Assessment Platform Backend
+
+## Project Overview
+
+This is a FastAPI-based backend application for an AI-powered hiring assessment platform. The system enables HR professionals to create and manage assessments for job candidates, while allowing candidates to take assessments and review their results.
+
+The application follows a clean architecture with proper separation of concerns:
+- **API Layer**: Handles HTTP requests and responses
+- **Service Layer**: Contains business logic
+- **Database Layer**: Manages database connections and sessions
+- **Model Layer**: Defines database models using SQLAlchemy
+- **Schema Layer**: Defines Pydantic schemas for request/response validation
+
+## Technologies Used
+
+- **Python 3.11**
+- **FastAPI**: Modern, fast web framework for building APIs
+- **SQLAlchemy**: SQL toolkit and ORM for database operations
+- **SQLite**: Lightweight database for development
+- **Alembic**: Database migration tool
+- **Pydantic**: Data validation and settings management
+- **UUID**: For generating unique identifiers
+
+## Architecture Components
+
+### Directory Structure
+```
+backend/
+├── api/                 # API route definitions
+│   ├── user_routes.py   # User registration/login endpoints
+│   ├── job_routes.py    # Job-related endpoints
+│   ├── assessment_routes.py # Assessment-related endpoints
+│   ├── application_routes.py # Application-related endpoints
+│   └── routes.py        # Root and health check endpoints
+├── database/            # Database connection utilities
+│   └── database.py      # Database engine and session management
+├── models/              # SQLAlchemy models
+│   ├── user.py          # User model
+│   ├── job.py           # Job model
+│   ├── assessment.py    # Assessment model
+│   ├── application.py   # Application model
+│   └── base.py          # Base model class
+├── schemas/             # Pydantic schemas
+│   ├── user.py          # User schemas
+│   ├── job.py           # Job schemas
+│   ├── assessment.py    # Assessment schemas
+│   ├── application.py   # Application schemas
+│   └── 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
+│   └── base_service.py  # Generic service functions
+├── alembic/             # Database migration files
+├── config.py            # Application configuration
+├── logging_config.py    # Logging configuration
+├── main.py              # Application entry point
+├── .env                 # Environment variables
+└── requirements.txt     # Python dependencies
+```
+
+### Key Features
+
+1. **User Management**:
+   - Registration and authentication
+   - Role-based access (HR vs Applicant)
+
+2. **Job Management**:
+   - Create, update, delete job postings
+   - Manage job details and requirements
+
+3. **Assessment Management**:
+   - Create assessments linked to jobs
+   - Define questions and passing scores
+   - Regenerate assessments with new questions
+
+4. **Application Management**:
+   - Submit applications with answers
+   - Track application results and scores
+
+### API Endpoints
+
+#### Registration
+- `POST /registration/signup` - User registration
+- `POST /registration/login` - User login
+- `POST /registration/logout` - User logout
+
+#### Users
+- `GET /users/{id}` - Get user details
+
+#### Jobs
+- `GET /jobs` - List jobs
+- `GET /jobs/{id}` - Get job details
+- `POST /jobs` - Create job
+- `PATCH /jobs/{id}` - Update job
+- `DELETE /jobs/{id}` - Delete job
+
+#### 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
+- `PATCH /assessments/jobs/{jid}/{aid}` - Update assessment
+- `DELETE /assessments/jobs/{jid}/{aid}` - Delete assessment
+
+#### Applications
+- `GET /applications/jobs/{jid}/assessments/{aid}` - List applications
+- `POST /applications/jobs/{jid}/assessments/{aid}` - Create application
+
+#### Health Check
+- `GET /` - Root endpoint
+- `GET /health` - Health check endpoint
+
+## Configuration
+
+The application uses a `.env` file for configuration, managed through the `config.py` file:
+
+```env
+# Database Configuration
+DATABASE_URL=sqlite:///./assessment_platform.db
+
+# Server Configuration
+HOST=0.0.0.0
+PORT=8000
+DEBUG=False
+
+# Logging Configuration
+LOG_LEVEL=INFO
+LOG_FILE=app.log
+LOG_FORMAT=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+
+# JWT Configuration (for future use)
+SECRET_KEY=your-secret-key-here
+ALGORITHM=HS256
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+
+# Application Configuration
+APP_NAME=AI-Powered Hiring Assessment Platform
+APP_VERSION=0.1.0
+APP_DESCRIPTION=MVP for managing hiring assessments using AI
+```
+
+## Building and Running
+
+### Prerequisites
+- Python 3.11+
+- pip package manager
+
+### Setup Instructions
+
+1. **Install Dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+   
+2. **Set Up Environment Variables**:
+   Copy the `.env.example` file to `.env` and adjust the values as needed.
+
+3. **Run Database Migrations**:
+   ```bash
+   alembic upgrade head
+   ```
+
+4. **Start the Application**:
+   ```bash
+   python main.py
+   ```
+   
+   Or using uvicorn directly:
+   ```bash
+   uvicorn main:app --host 0.0.0.0 --port 8000 --reload
+   ```
+
+### Development Mode
+For development, you can run the application with hot-reloading enabled:
+```bash
+uvicorn main:app --reload --host 0.0.0.0 --port 8000
+```
+
+## Testing
+
+To run tests (when available):
+```bash
+pytest
+```
+
+## Logging
+
+The application implements comprehensive logging through the `logging_config.py` module:
+- Logs are written to both file (`app.log`) and console
+- Log level can be configured via the `LOG_LEVEL` environment variable
+- Different log levels (DEBUG, INFO, WARNING, ERROR) are used appropriately
+- All major operations are logged with contextual information
+
+## Database Migrations
+
+The application uses Alembic for database migrations:
+- To create a new migration: `alembic revision --autogenerate -m "Description"`
+- To apply migrations: `alembic upgrade head`
+- To check current migration status: `alembic current`
+
+## Development Conventions
+
+1. **Code Style**:
+   - Follow PEP 8 guidelines
+   - Use type hints for all function parameters and return values
+   - Write docstrings for all public functions and classes
+
+2. **Error Handling**:
+   - Use appropriate HTTP status codes
+   - Return meaningful error messages
+   - Log errors appropriately
+
+3. **Security**:
+   - Passwords should be hashed (currently using placeholder)
+   - Input validation through Pydantic schemas
+   - SQL injection prevention through SQLAlchemy ORM
+
+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
+
+## 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. 
+

backend/README.md

@@ -0,0 +1,41 @@
+# AI-Powered Hiring Assessment Platform - Demo Credentials
+
+## HR Accounts
+
+| Name | Email | Password |
+|------|-------|----------|
+| Sarah Johnson | sarah.johnson@demo.com | password123 |
+| Michael Chen | michael.chen@demo.com | password123 |
+| Emma Rodriguez | emma.rodriguez@demo.com | password123 |
+| David Wilson | david.wilson@demo.com | password123 |
+
+## Candidate Accounts
+
+| Name | Email | Password |
+|------|-------|----------|
+| Alex Thompson | alex.thompson@demo.com | password123 |
+| Jessica Lee | jessica.lee@demo.com | password123 |
+| Ryan Patel | ryan.patel@demo.com | password123 |
+| Olivia Kim | olivia.kim@demo.com | password123 |
+
+## Sample Jobs & Assessments
+
+The demo includes the following sample data:
+- 4 job postings with varying seniority levels
+- 4 assessments linked to these jobs
+- Sample applications submitted by candidates
+
+## Getting Started
+
+1. Clone the repository
+2. Install dependencies: `pip install -r requirements.txt`
+3. Set up environment variables (copy `.env.example` to `.env`)
+4. Run database migrations: `alembic upgrade head`
+5. Start the application: `python main.py`
+6. Access the API documentation at `http://localhost:8000/docs`
+
+## API Usage
+
+- HR users can create jobs and assessments
+- Candidates can apply to jobs and take assessments
+- All accounts are pre-populated with sample data for demonstration

backend/alembic.ini

@@ -0,0 +1,149 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts.
+# this is typically a path given in POSIX (e.g. forward slashes)
+# format, relative to the token %(here)s which refers to the location of this
+# ini file
+script_location = %(here)s/alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+# Or organize into date-based subdirectories (requires recursive_version_locations = true)
+# file_template = %%(year)d/%%(month).2d/%%(day).2d_%%(hour).2d%%(minute).2d_%%(second).2d_%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.  for multiple paths, the path separator
+# is defined by "path_separator" below.
+prepend_sys_path = .
+
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the tzdata library which can be installed by adding
+# `alembic[tz]` to the pip requirements.
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to <script_location>/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "path_separator"
+# below.
+# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions
+
+# path_separator; This indicates what character is used to split lists of file
+# paths, including version_locations and prepend_sys_path within configparser
+# files such as alembic.ini.
+# The default rendered in new alembic.ini files is "os", which uses os.pathsep
+# to provide os-dependent path splitting.
+#
+# Note that in order to support legacy alembic.ini files, this default does NOT
+# take place if path_separator is not present in alembic.ini.  If this
+# option is omitted entirely, fallback logic is as follows:
+#
+# 1. Parsing of the version_locations option falls back to using the legacy
+#    "version_path_separator" key, which if absent then falls back to the legacy
+#    behavior of splitting on spaces and/or commas.
+# 2. Parsing of the prepend_sys_path option falls back to the legacy
+#    behavior of splitting on spaces, commas, or colons.
+#
+# Valid values for path_separator are:
+#
+# path_separator = :
+# path_separator = ;
+# path_separator = space
+# path_separator = newline
+#
+# Use os.pathsep. Default configuration used for new projects.
+path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# database URL.  This is consumed by the user-maintained env.py script only.
+# other means of configuring database URLs may be customized within the env.py
+# file.
+sqlalchemy.url = sqlite:///assessment_platform.db
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the module runner, against the "ruff" module
+# hooks = ruff
+# ruff.type = module
+# ruff.module = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Alternatively, use the exec runner to execute a binary found on your PATH
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration.  This is also consumed by the user-maintained
+# env.py script only.
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

backend/alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

backend/alembic/env.py

@@ -0,0 +1,83 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+# Import our models
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from models import Base  # Import the Base from our models __init__ file
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

backend/alembic/script.py.mako

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}

backend/alembic/versions/1172a2fbb171_initial_migration_for_assessment_.py

@@ -0,0 +1,117 @@
+"""Initial migration for assessment platform
+
+Revision ID: 1172a2fbb171
+Revises: 
+Create Date: 2026-02-02 23:15:34.140221
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '1172a2fbb171'
+down_revision: Union[str, Sequence[str], None] = None
+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.create_table('users',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('email', sa.String(), nullable=False),
+    sa.Column('password_hash', sa.String(), nullable=False),
+    sa.Column('user_type', sa.String(), nullable=False),
+    sa.Column('created_at', sa.DateTime(), nullable=True),
+    sa.CheckConstraint("user_type IN ('hr', 'candidate')", name='valid_user_type'),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_users_email'), 'users', ['email'], unique=True)
+    op.create_index(op.f('ix_users_id'), 'users', ['id'], unique=False)
+    op.create_table('assessments',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('job_title', sa.String(), nullable=False),
+    sa.Column('experience_level', sa.String(), nullable=True),
+    sa.Column('required_skills', sa.Text(), nullable=True),
+    sa.Column('job_description', sa.Text(), nullable=True),
+    sa.Column('num_questions', sa.Integer(), nullable=True),
+    sa.Column('assessment_description', sa.Text(), nullable=True),
+    sa.Column('hr_id', sa.Integer(), nullable=True),
+    sa.Column('is_active', sa.Boolean(), nullable=True),
+    sa.Column('created_at', sa.DateTime(), nullable=True),
+    sa.ForeignKeyConstraint(['hr_id'], ['users.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_assessments_id'), 'assessments', ['id'], unique=False)
+    op.create_table('candidates_assessments',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('candidate_id', sa.Integer(), nullable=True),
+    sa.Column('assessment_id', sa.Integer(), nullable=True),
+    sa.Column('started_at', sa.DateTime(), nullable=True),
+    sa.Column('completed_at', sa.DateTime(), nullable=True),
+    sa.Column('total_score', sa.Integer(), nullable=True),
+    sa.Column('status', sa.String(), nullable=True),
+    sa.ForeignKeyConstraint(['assessment_id'], ['assessments.id'], ),
+    sa.ForeignKeyConstraint(['candidate_id'], ['users.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_candidates_assessments_id'), 'candidates_assessments', ['id'], unique=False)
+    op.create_table('questions',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('assessment_id', sa.Integer(), nullable=True),
+    sa.Column('question_text', sa.Text(), nullable=False),
+    sa.Column('question_type', sa.String(), nullable=False),
+    sa.Column('is_knockout', sa.Boolean(), nullable=True),
+    sa.Column('weight', sa.Integer(), nullable=True),
+    sa.Column('max_score', sa.Integer(), nullable=True),
+    sa.Column('created_at', sa.DateTime(), nullable=True),
+    sa.CheckConstraint("question_type IN ('text', 'true_false', 'multiple_choice')", name='valid_question_type'),
+    sa.ForeignKeyConstraint(['assessment_id'], ['assessments.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_questions_id'), 'questions', ['id'], unique=False)
+    op.create_table('answers',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('candidate_assessment_id', sa.Integer(), nullable=True),
+    sa.Column('question_id', sa.Integer(), nullable=True),
+    sa.Column('answer_text', sa.Text(), nullable=True),
+    sa.Column('score_awarded', sa.Integer(), nullable=True),
+    sa.Column('ai_evaluation', sa.Text(), nullable=True),
+    sa.Column('evaluated_at', sa.DateTime(), nullable=True),
+    sa.ForeignKeyConstraint(['candidate_assessment_id'], ['candidates_assessments.id'], ),
+    sa.ForeignKeyConstraint(['question_id'], ['questions.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_answers_id'), 'answers', ['id'], unique=False)
+    op.create_table('question_tags',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('question_id', sa.Integer(), nullable=True),
+    sa.Column('tag_name', sa.String(), nullable=False),
+    sa.ForeignKeyConstraint(['question_id'], ['questions.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_question_tags_id'), 'question_tags', ['id'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_question_tags_id'), table_name='question_tags')
+    op.drop_table('question_tags')
+    op.drop_index(op.f('ix_answers_id'), table_name='answers')
+    op.drop_table('answers')
+    op.drop_index(op.f('ix_questions_id'), table_name='questions')
+    op.drop_table('questions')
+    op.drop_index(op.f('ix_candidates_assessments_id'), table_name='candidates_assessments')
+    op.drop_table('candidates_assessments')
+    op.drop_index(op.f('ix_assessments_id'), table_name='assessments')
+    op.drop_table('assessments')
+    op.drop_index(op.f('ix_users_id'), table_name='users')
+    op.drop_index(op.f('ix_users_email'), table_name='users')
+    op.drop_table('users')
+    # ### end Alembic commands ###

backend/alembic/versions/91905f51740d_final_structure_for_technical_.py

@@ -0,0 +1,32 @@
+"""Final structure for technical requirements
+
+Revision ID: 91905f51740d
+Revises: 1172a2fbb171
+Create Date: 2026-02-03 00:46:41.529962
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '91905f51740d'
+down_revision: Union[str, Sequence[str], None] = '1172a2fbb171'
+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! ###
+    pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###

backend/alembic/versions/9facd9b60600_seed_demo_data_with_hr_and_candidate_.py

@@ -0,0 +1,396 @@
+"""Seed demo data with HR and candidate accounts
+
+Revision ID: 9facd9b60600
+Revises: 91905f51740d
+Create Date: 2026-02-04 15:47:05.330740
+
+"""
+from typing import Sequence, Union
+import uuid
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.sql import table, column
+from sqlalchemy import String, Integer, Boolean, Text
+import json
+from utils.password_utils import get_password_hash
+
+
+# revision identifiers, used by Alembic.
+revision: str = '9facd9b60600'
+down_revision: Union[str, Sequence[str], None] = '91905f51740d'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema with demo data."""
+    # Create table objects for insertion
+    users_table = table('users',
+        column('id', String),
+        column('first_name', String),
+        column('last_name', String),
+        column('email', String),
+        column('password', String),
+        column('role', String)
+    )
+
+    jobs_table = table('jobs',
+        column('id', String),
+        column('title', String),
+        column('seniority', String),
+        column('description', Text),
+        column('skill_categories', String),
+        column('active', Boolean)
+    )
+
+    assessments_table = table('assessments',
+        column('id', String),
+        column('job_id', String),
+        column('title', String),
+        column('duration', Integer),
+        column('passing_score', Integer),
+        column('questions', Text),
+        column('active', Boolean)
+    )
+
+    # Hash the password for all users
+    password_hash = get_password_hash("password123")
+
+    # Insert HR users
+    hr_users = [
+        {
+            'id': str(uuid.uuid4()),
+            'first_name': 'Sarah',
+            'last_name': 'Johnson',
+            'email': 'sarah.johnson@demo.com',
+            'password': password_hash,
+            'role': 'hr'
+        },
+        {
+            'id': str(uuid.uuid4()),
+            'first_name': 'Michael',
+            'last_name': 'Chen',
+            'email': 'michael.chen@demo.com',
+            'password': password_hash,
+            'role': 'hr'
+        },
+        {
+            'id': str(uuid.uuid4()),
+            'first_name': 'Emma',
+            'last_name': 'Rodriguez',
+            'email': 'emma.rodriguez@demo.com',
+            'password': password_hash,
+            'role': 'hr'
+        },
+        {
+            'id': str(uuid.uuid4()),
+            'first_name': 'David',
+            'last_name': 'Wilson',
+            'email': 'david.wilson@demo.com',
+            'password': password_hash,
+            'role': 'hr'
+        }
+    ]
+
+    # Insert candidate users
+    candidate_users = [
+        {
+            'id': str(uuid.uuid4()),
+            'first_name': 'Alex',
+            'last_name': 'Thompson',
+            'email': 'alex.thompson@demo.com',
+            'password': password_hash,
+            'role': 'applicant'
+        },
+        {
+            'id': str(uuid.uuid4()),
+            'first_name': 'Jessica',
+            'last_name': 'Lee',
+            'email': 'jessica.lee@demo.com',
+            'password': password_hash,
+            'role': 'applicant'
+        },
+        {
+            'id': str(uuid.uuid4()),
+            'first_name': 'Ryan',
+            'last_name': 'Patel',
+            'email': 'ryan.patel@demo.com',
+            'password': password_hash,
+            'role': 'applicant'
+        },
+        {
+            'id': str(uuid.uuid4()),
+            'first_name': 'Olivia',
+            'last_name': 'Kim',
+            'email': 'olivia.kim@demo.com',
+            'password': password_hash,
+            'role': 'applicant'
+        }
+    ]
+
+    # Combine all users
+    all_users = hr_users + candidate_users
+
+    # Insert users
+    op.bulk_insert(users_table, all_users)
+
+    # Insert sample jobs
+    jobs = [
+        {
+            'id': str(uuid.uuid4()),
+            'title': 'Senior Python Developer',
+            'seniority': 'senior',
+            'description': 'We are looking for an experienced Python developer to join our team. The ideal candidate should have experience with web frameworks, databases, and cloud technologies.',
+            'skill_categories': json.dumps(['python', 'django', 'flask', 'sql', 'cloud']),
+            'active': True
+        },
+        {
+            'id': str(uuid.uuid4()),
+            'title': 'Junior Data Analyst',
+            'seniority': 'junior',
+            'description': 'We are looking for a Junior Data Analyst to join our analytics team. The ideal candidate should have experience with data visualization, statistical analysis, and SQL queries.',
+            'skill_categories': json.dumps(['sql', 'python', 'excel', 'tableau', 'statistics']),
+            'active': True
+        },
+        {
+            'id': str(uuid.uuid4()),
+            'title': 'Mid-Level Software Engineer',
+            'seniority': 'mid',
+            'description': 'We are looking for a Mid-Level Software Engineer with experience in Python, Django, and REST APIs.',
+            'skill_categories': json.dumps(['python', 'django', 'rest-api', 'sql', 'testing']),
+            'active': True
+        },
+        {
+            'id': str(uuid.uuid4()),
+            'title': 'DevOps Engineer',
+            'seniority': 'mid',
+            'description': 'We are looking for a DevOps Engineer to help us improve our CI/CD pipelines and infrastructure automation.',
+            'skill_categories': json.dumps(['docker', 'kubernetes', 'aws', 'jenkins', 'terraform']),
+            'active': True
+        }
+    ]
+
+    # Insert jobs
+    op.bulk_insert(jobs_table, jobs)
+
+    # Create a mapping of job titles to IDs for assessment creation
+    job_mapping = {job['title']: job['id'] for job in jobs}
+
+    # Create sample assessments with questions
+    assessments = []
+
+    # Python Developer Assessment
+    python_questions = [
+        {
+            "id": str(uuid.uuid4()),
+            "text": "What is the difference between a list and a tuple in Python?",
+            "weight": 3,
+            "skill_categories": ["python"],
+            "type": "text_based",
+            "options": [],
+            "correct_options": []
+        },
+        {
+            "id": str(uuid.uuid4()),
+            "text": "Which of the following is a mutable data type in Python?",
+            "weight": 2,
+            "skill_categories": ["python"],
+            "type": "choose_one",
+            "options": [
+                {"text": "Tuple", "value": "a"},
+                {"text": "String", "value": "b"},
+                {"text": "List", "value": "c"},
+                {"text": "Integer", "value": "d"}
+            ],
+            "correct_options": ["c"]
+        },
+        {
+            "id": str(uuid.uuid4()),
+            "text": "Which of the following are Python web frameworks?",
+            "weight": 3,
+            "skill_categories": ["python", "web-development"],
+            "type": "choose_many",
+            "options": [
+                {"text": "Django", "value": "a"},
+                {"text": "Express", "value": "b"},
+                {"text": "Flask", "value": "c"},
+                {"text": "Spring", "value": "d"}
+            ],
+            "correct_options": ["a", "c"]
+        }
+    ]
+
+    assessments.append({
+        'id': str(uuid.uuid4()),
+        'job_id': job_mapping['Senior Python Developer'],
+        'title': 'Python Programming Skills Assessment',
+        'duration': 1800,  # 30 minutes
+        'passing_score': 70,
+        'questions': json.dumps(python_questions),
+        'active': True
+    })
+
+    # Data Analyst Assessment
+    data_analyst_questions = [
+        {
+            "id": str(uuid.uuid4()),
+            "text": "What is the purpose of GROUP BY clause in SQL?",
+            "weight": 3,
+            "skill_categories": ["sql"],
+            "type": "text_based",
+            "options": [],
+            "correct_options": []
+        },
+        {
+            "id": str(uuid.uuid4()),
+            "text": "Which of the following are data visualization tools?",
+            "weight": 2,
+            "skill_categories": ["data-visualization"],
+            "type": "choose_many",
+            "options": [
+                {"text": "Tableau", "value": "a"},
+                {"text": "Power BI", "value": "b"},
+                {"text": "Excel", "value": "c"},
+                {"text": "Notepad", "value": "d"}
+            ],
+            "correct_options": ["a", "b", "c"]
+        },
+        {
+            "id": str(uuid.uuid4()),
+            "text": "What does the acronym ETL stand for?",
+            "weight": 2,
+            "skill_categories": ["data-processing"],
+            "type": "choose_one",
+            "options": [
+                {"text": "Extract, Transform, Load", "value": "a"},
+                {"text": "Edit, Transfer, Link", "value": "b"},
+                {"text": "Encode, Transmit, Log", "value": "c"},
+                {"text": "Estimate, Test, Learn", "value": "d"}
+            ],
+            "correct_options": ["a"]
+        }
+    ]
+
+    assessments.append({
+        'id': str(uuid.uuid4()),
+        'job_id': job_mapping['Junior Data Analyst'],
+        'title': 'Data Analysis Skills Assessment',
+        'duration': 2400,  # 40 minutes
+        'passing_score': 65,
+        'questions': json.dumps(data_analyst_questions),
+        'active': True
+    })
+
+    # Software Engineer Assessment
+    software_eng_questions = [
+        {
+            "id": str(uuid.uuid4()),
+            "text": "Explain the difference between REST and GraphQL APIs.",
+            "weight": 4,
+            "skill_categories": ["api-design"],
+            "type": "text_based",
+            "options": [],
+            "correct_options": []
+        },
+        {
+            "id": str(uuid.uuid4()),
+            "text": "Which HTTP status code indicates a successful request?",
+            "weight": 1,
+            "skill_categories": ["web-development"],
+            "type": "choose_one",
+            "options": [
+                {"text": "200", "value": "a"},
+                {"text": "404", "value": "b"},
+                {"text": "500", "value": "c"},
+                {"text": "301", "value": "d"}
+            ],
+            "correct_options": ["a"]
+        },
+        {
+            "id": str(uuid.uuid4()),
+            "text": "Which of the following are version control systems?",
+            "weight": 2,
+            "skill_categories": ["development-tools"],
+            "type": "choose_many",
+            "options": [
+                {"text": "Git", "value": "a"},
+                {"text": "SVN", "value": "b"},
+                {"text": "Mercurial", "value": "c"},
+                {"text": "Docker", "value": "d"}
+            ],
+            "correct_options": ["a", "b", "c"]
+        }
+    ]
+
+    assessments.append({
+        'id': str(uuid.uuid4()),
+        'job_id': job_mapping['Mid-Level Software Engineer'],
+        'title': 'Software Engineering Fundamentals Assessment',
+        'duration': 1800,  # 30 minutes
+        'passing_score': 75,
+        'questions': json.dumps(software_eng_questions),
+        'active': True
+    })
+
+    # DevOps Assessment
+    devops_questions = [
+        {
+            "id": str(uuid.uuid4()),
+            "text": "What is the main purpose of Docker containers?",
+            "weight": 3,
+            "skill_categories": ["containerization"],
+            "type": "text_based",
+            "options": [],
+            "correct_options": []
+        },
+        {
+            "id": str(uuid.uuid4()),
+            "text": "Which of the following are container orchestration platforms?",
+            "weight": 3,
+            "skill_categories": ["orchestration"],
+            "type": "choose_many",
+            "options": [
+                {"text": "Kubernetes", "value": "a"},
+                {"text": "Docker Swarm", "value": "b"},
+                {"text": "Apache Mesos", "value": "c"},
+                {"text": "Jenkins", "value": "d"}
+            ],
+            "correct_options": ["a", "b", "c"]
+        },
+        {
+            "id": str(uuid.uuid4()),
+            "text": "What does CI/CD stand for?",
+            "weight": 1,
+            "skill_categories": ["development-process"],
+            "type": "choose_one",
+            "options": [
+                {"text": "Continuous Integration/Continuous Deployment", "value": "a"},
+                {"text": "Computer Integrated Design", "value": "b"},
+                {"text": "Customer Identity and Data", "value": "c"},
+                {"text": "Cloud Infrastructure Development", "value": "d"}
+            ],
+            "correct_options": ["a"]
+        }
+    ]
+
+    assessments.append({
+        'id': str(uuid.uuid4()),
+        'job_id': job_mapping['DevOps Engineer'],
+        'title': 'DevOps Practices Assessment',
+        'duration': 2100,  # 35 minutes
+        'passing_score': 70,
+        'questions': json.dumps(devops_questions),
+        'active': True
+    })
+
+    # Insert assessments
+    op.bulk_insert(assessments_table, assessments)
+
+
+def downgrade() -> None:
+    """Downgrade schema - remove demo data."""
+    # Delete all records from the tables
+    op.execute("DELETE FROM applications")
+    op.execute("DELETE FROM assessments")
+    op.execute("DELETE FROM jobs")
+    op.execute("DELETE FROM users")

backend/api/application_routes.py

@@ -0,0 +1,88 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+import json
+
+from database.database import get_db
+from schemas import ApplicationCreate, ApplicationUpdate, ApplicationResponse, ApplicationListResponse, ApplicationDetailedResponse, ApplicationDetailedListResponse
+from services import create_application, get_application, get_applications_by_job_and_assessment, calculate_application_score
+from services.assessment_service import get_assessment
+from utils.dependencies import get_current_user
+from models.user import User
+from logging_config import get_logger
+
+# Create logger for this module
+logger = get_logger(__name__)
+
+router = APIRouter(prefix="/applications", tags=["applications"])
+
+@router.get("/jobs/{jid}/assessments/{aid}", response_model=ApplicationDetailedListResponse)
+def get_applications_list(jid: str, aid: str, page: int = 1, limit: int = 10, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    """Get list of applications for an assessment"""
+    logger.info(f"Retrieving applications list for job ID: {jid}, assessment ID: {aid}, page: {page}, limit: {limit} by user: {current_user.id}")
+    # Only HR users can view applications
+    if current_user.role != "hr":
+        logger.warning(f"Unauthorized attempt to view applications by user: {current_user.id} with role: {current_user.role}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only HR users can view applications"
+        )
+    skip = (page - 1) * limit
+    applications = get_applications_by_job_and_assessment(db, jid, aid, skip=skip, limit=limit)
+
+    # Calculate total count
+    total = len(get_applications_by_job_and_assessment(db, jid, aid, skip=0, limit=1000))  # Simplified for demo
+
+    # Convert answers from JSON string to list and calculate scores
+    application_responses = []
+    for application in applications:
+        application_dict = application.__dict__
+        if application.answers:
+            application_dict['answers'] = json.loads(application.answers)
+        else:
+            application_dict['answers'] = []
+
+        # Calculate score (placeholder)
+        application_dict['score'] = calculate_application_score(db, application.id)
+        application_dict['passing_score'] = 0.0  # Placeholder
+
+        application_responses.append(ApplicationResponse(**application_dict))
+
+    logger.info(f"Successfully retrieved {len(applications)} applications out of total {total} for job ID: {jid}, assessment ID: {aid}")
+    return ApplicationDetailedListResponse(
+        count=len(applications),
+        total=total,
+        data=application_responses
+    )
+
+@router.post("/jobs/{jid}/assessments/{aid}", response_model=dict)  # Returns just id as per requirements
+def create_new_application(jid: str, aid: str, application: ApplicationCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    """Create a new application for an assessment"""
+    logger.info(f"Creating new application for job ID: {jid}, assessment ID: {aid}, user ID: {application.user_id} by user: {current_user.id}")
+    # Only applicant users can create applications
+    if current_user.role != "applicant":
+        logger.warning(f"Unauthorized attempt to create application by user: {current_user.id} with role: {current_user.role}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only applicant users can submit applications"
+        )
+    # Ensure the user submitting the application is the same as the one in the request
+    if current_user.id != application.user_id:
+        logger.warning(f"User {current_user.id} attempted to submit application for user {application.user_id}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Cannot submit application for another user"
+        )
+
+    # Validate that the job and assessment exist and match
+    assessment_obj = get_assessment(db, aid)
+    if not assessment_obj or assessment_obj.job_id != jid:
+        logger.warning(f"Assessment not found for job ID: {jid}, assessment ID: {aid}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Assessment not found for this job"
+        )
+
+    db_application = create_application(db, application)
+    logger.info(f"Successfully created application with ID: {db_application.id} for job ID: {jid}, assessment ID: {aid}")
+    return {"id": db_application.id}

backend/api/assessment_routes.py

@@ -0,0 +1,148 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+import json
+
+from database.database import get_db
+from schemas import AssessmentCreate, AssessmentUpdate, AssessmentRegenerate, AssessmentResponse, AssessmentListResponse, AssessmentDetailedResponse
+from services import create_assessment, get_assessment, get_assessments_by_job, update_assessment, regenerate_assessment, delete_assessment
+from utils.dependencies import get_current_user
+from models.user import User
+from logging_config import get_logger
+
+# Create logger for this module
+logger = get_logger(__name__)
+
+router = APIRouter(prefix="/assessments", tags=["assessments"])
+
+@router.get("/jobs/{jid}", response_model=AssessmentListResponse)
+def get_assessments_list(jid: str, page: int = 1, limit: int = 10, db: Session = Depends(get_db)):
+    """Get list of assessments for a job"""
+    logger.info(f"Retrieving assessments list for job ID: {jid}, page: {page}, limit: {limit}")
+    skip = (page - 1) * limit
+    assessments = get_assessments_by_job(db, jid, skip=skip, limit=limit)
+
+    # Calculate total count
+    total = len(get_assessments_by_job(db, jid, skip=0, limit=1000))  # Simplified for demo
+
+    # Convert questions from JSON string to list and add questions_count
+    assessment_responses = []
+    for assessment in assessments:
+        assessment_dict = assessment.__dict__
+        if assessment.questions:
+            assessment_dict['questions'] = json.loads(assessment.questions)
+        else:
+            assessment_dict['questions'] = []
+
+        # Add questions count
+        assessment_dict['questions_count'] = len(assessment_dict['questions'])
+        assessment_responses.append(AssessmentResponse(**assessment_dict))
+
+    logger.info(f"Successfully retrieved {len(assessments)} assessments out of total {total} for job ID: {jid}")
+    return AssessmentListResponse(
+        count=len(assessments),
+        total=total,
+        data=assessment_responses
+    )
+
+@router.get("/jobs/{jid}/{aid}", response_model=AssessmentDetailedResponse)
+def get_assessment_details(jid: str, aid: str, db: Session = Depends(get_db)):
+    """Get assessment details"""
+    logger.info(f"Retrieving assessment details for job ID: {jid}, assessment ID: {aid}")
+    assessment = get_assessment(db, aid)
+    if not assessment or assessment.job_id != jid:
+        logger.warning(f"Assessment not found for job ID: {jid}, assessment ID: {aid}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Assessment not found for this job"
+        )
+
+    # Convert questions from JSON string to list and add questions_count
+    assessment_dict = assessment.__dict__
+    if assessment.questions:
+        assessment_dict['questions'] = json.loads(assessment.questions)
+    else:
+        assessment_dict['questions'] = []
+
+    assessment_dict['questions_count'] = len(assessment_dict['questions'])
+
+    logger.info(f"Successfully retrieved assessment details for job ID: {jid}, assessment ID: {assessment.id}")
+    return AssessmentDetailedResponse(**assessment_dict)
+
+@router.post("/jobs/{id}", response_model=dict)  # Returns just id as per requirements
+def create_new_assessment(id: str, assessment: AssessmentCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    """Create a new assessment for a job"""
+    logger.info(f"Creating new assessment for job ID: {id}, title: {assessment.title} by user: {current_user.id}")
+    # Only HR users can create assessments
+    if current_user.role != "hr":
+        logger.warning(f"Unauthorized attempt to create assessment by user: {current_user.id} with role: {current_user.role}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only HR users can create assessments"
+        )
+    db_assessment = create_assessment(db, id, assessment)
+    logger.info(f"Successfully created assessment with ID: {db_assessment.id} for job ID: {id}")
+    return {"id": db_assessment.id}
+
+@router.patch("/jobs/{jid}/{aid}/regenerate")
+def regenerate_assessment(jid: str, aid: str, regenerate_data: AssessmentRegenerate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    """Regenerate an assessment"""
+    logger.info(f"Regenerating assessment for job ID: {jid}, assessment ID: {aid} by user: {current_user.id}")
+    # Only HR users can regenerate assessments
+    if current_user.role != "hr":
+        logger.warning(f"Unauthorized attempt to regenerate assessment by user: {current_user.id} with role: {current_user.role}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only HR users can regenerate assessments"
+        )
+    updated_assessment = regenerate_assessment(db, aid, **regenerate_data.model_dump(exclude_unset=True))
+    if not updated_assessment:
+        logger.warning(f"Assessment not found for regeneration with job ID: {jid}, assessment ID: {aid}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Assessment not found"
+        )
+    logger.info(f"Successfully regenerated assessment with ID: {updated_assessment.id} for job ID: {jid}")
+    return {}
+
+@router.patch("/jobs/{jid}/{aid}")
+def update_existing_assessment(jid: str, aid: str, assessment_update: AssessmentUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    """Update an existing assessment"""
+    logger.info(f"Updating assessment for job ID: {jid}, assessment ID: {aid} by user: {current_user.id}")
+    # Only HR users can update assessments
+    if current_user.role != "hr":
+        logger.warning(f"Unauthorized attempt to update assessment by user: {current_user.id} with role: {current_user.role}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only HR users can update assessments"
+        )
+    updated_assessment = update_assessment(db, aid, **assessment_update.dict(exclude_unset=True))
+    if not updated_assessment:
+        logger.warning(f"Assessment not found for update with job ID: {jid}, assessment ID: {aid}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Assessment not found"
+        )
+    logger.info(f"Successfully updated assessment with ID: {updated_assessment.id} for job ID: {jid}")
+    return {}
+
+@router.delete("/jobs/{jid}/{aid}")
+def delete_existing_assessment(jid: str, aid: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    """Delete an assessment"""
+    logger.info(f"Deleting assessment for job ID: {jid}, assessment ID: {aid} by user: {current_user.id}")
+    # Only HR users can delete assessments
+    if current_user.role != "hr":
+        logger.warning(f"Unauthorized attempt to delete assessment by user: {current_user.id} with role: {current_user.role}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only HR users can delete assessments"
+        )
+    success = delete_assessment(db, aid)
+    if not success:
+        logger.warning(f"Assessment not found for deletion with job ID: {jid}, assessment ID: {aid}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Assessment not found"
+        )
+    logger.info(f"Successfully deleted assessment with ID: {aid} for job ID: {jid}")
+    return {}

backend/api/job_routes.py

@@ -0,0 +1,127 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List
+import json
+
+from database.database import get_db
+from schemas import JobCreate, JobUpdate, JobResponse, JobListResponse
+from services import create_job, get_job, get_active_jobs, update_job, delete_job, get_job_applicants_count
+from utils.dependencies import get_current_user
+from models.user import User
+from logging_config import get_logger
+
+# Create logger for this module
+logger = get_logger(__name__)
+
+router = APIRouter(prefix="/jobs", tags=["jobs"])
+
+@router.get("", response_model=JobListResponse)
+def get_jobs_list(page: int = 1, limit: int = 10, db: Session = Depends(get_db)):
+    """Get list of jobs"""
+    logger.info(f"Retrieving jobs list - page: {page}, limit: {limit}")
+    skip = (page - 1) * limit
+    jobs = get_active_jobs(db, skip=skip, limit=limit)
+
+    # Calculate total count
+    total = len(get_active_jobs(db, skip=0, limit=1000))  # Simplified for demo
+
+    # Convert skill_categories from JSON string to list and add applicants_count
+    job_responses = []
+    for job in jobs:
+        job_dict = job.__dict__
+        if job.skill_categories:
+            job_dict['skill_categories'] = json.loads(job.skill_categories)
+        else:
+            job_dict['skill_categories'] = []
+
+        # Add applicants count
+        job_dict['applicants_count'] = get_job_applicants_count(db, job.id)
+        job_responses.append(JobResponse(**job_dict))
+
+    logger.info(f"Successfully retrieved {len(jobs)} jobs out of total {total}")
+    return JobListResponse(
+        count=len(jobs),
+        total=total,
+        data=job_responses
+    )
+
+@router.get("/{id}", response_model=JobResponse)
+def get_job_details(id: str, db: Session = Depends(get_db)):
+    """Get job details by ID"""
+    logger.info(f"Retrieving job details for ID: {id}")
+    job = get_job(db, id)
+    if not job:
+        logger.warning(f"Job not found for ID: {id}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Job not found"
+        )
+
+    # Convert skill_categories from JSON string to list and add applicants_count
+    job_dict = job.__dict__
+    if job.skill_categories:
+        job_dict['skill_categories'] = json.loads(job.skill_categories)
+    else:
+        job_dict['skill_categories'] = []
+
+    job_dict['applicants_count'] = get_job_applicants_count(db, job.id)
+
+    logger.info(f"Successfully retrieved job details for ID: {job.id}")
+    return JobResponse(**job_dict)
+
+@router.post("", response_model=dict)  # Returns just id as per requirements
+def create_new_job(job: JobCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    """Create a new job"""
+    logger.info(f"Creating new job with title: {job.title} by user: {current_user.id}")
+    # Only HR users can create jobs
+    if current_user.role != "hr":
+        logger.warning(f"Unauthorized attempt to create job by user: {current_user.id} with role: {current_user.role}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only HR users can create jobs"
+        )
+    db_job = create_job(db, job)
+    logger.info(f"Successfully created job with ID: {db_job.id}")
+    return {"id": db_job.id}
+
+@router.patch("/{id}")
+def update_existing_job(id: str, job_update: JobUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    """Update an existing job"""
+    logger.info(f"Updating job with ID: {id} by user: {current_user.id}")
+    # Only HR users can update jobs
+    if current_user.role != "hr":
+        logger.warning(f"Unauthorized attempt to update job by user: {current_user.id} with role: {current_user.role}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only HR users can update jobs"
+        )
+    updated_job = update_job(db, id, **job_update.dict(exclude_unset=True))
+    if not updated_job:
+        logger.warning(f"Job not found for update with ID: {id}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Job not found"
+        )
+    logger.info(f"Successfully updated job with ID: {updated_job.id}")
+    return {}
+
+@router.delete("/{id}")
+def delete_existing_job(id: str, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    """Delete a job"""
+    logger.info(f"Deleting job with ID: {id} by user: {current_user.id}")
+    # Only HR users can delete jobs
+    if current_user.role != "hr":
+        logger.warning(f"Unauthorized attempt to delete job by user: {current_user.id} with role: {current_user.role}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only HR users can delete jobs"
+        )
+    success = delete_job(db, id)
+    if not success:
+        logger.warning(f"Job not found for deletion with ID: {id}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Job not found"
+        )
+    logger.info(f"Successfully deleted job with ID: {id}")
+    return {}

backend/api/routes.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from database.database import get_db
+
+router = APIRouter()
+
+# Health check endpoint
+@router.get("/", response_model=dict)
+def read_root():
+    """Root endpoint"""
+    return {"message": "Welcome to AI-Powered Hiring Assessment Platform API"}
+
+@router.get("/health", status_code=200)
+def health_check(db: Session = Depends(get_db)):
+    """Health check endpoint to verify API is running and database is accessible"""
+    try:
+        # Test database connection using SQLAlchemy
+        # Execute a simple query to test the connection
+        db.execute("SELECT 1")
+
+        return {
+            "status": "healthy",
+            "database": "connected",
+            "timestamp": "2026-02-02T00:00:00"  # Placeholder timestamp
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Health check failed: {str(e)}")

backend/api/user_routes.py

@@ -0,0 +1,76 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+import logging
+
+from database.database import get_db
+from schemas import UserCreate, UserLogin, UserLogout, UserResponse, TokenResponse
+from services import get_user, login_user_service, register_user_service
+from utils.dependencies import get_current_user
+from models.user import User
+from logging_config import get_logger
+
+# Create logger for this module
+logger = get_logger(__name__)
+
+router = APIRouter(prefix="/users", tags=["users"])
+
+# Registration endpoints
+@router.post("/registration/signup", response_model=TokenResponse)
+def register_user_endpoint(user: UserCreate, db: Session = Depends(get_db)):
+    """Register a new user"""
+    logger.info(f"Registering new user with email: {user.email}")
+
+    # Use the authentication service to register the user and generate a token
+    token_response = register_user_service(db, user)
+    return token_response
+
+@router.post("/registration/login", response_model=TokenResponse)
+def login_user_endpoint(credentials: UserLogin, db: Session = Depends(get_db)):
+    """Login a user"""
+    logger.info(f"Login attempt for user: {credentials.email}")
+
+    # Use the authentication service to login the user and generate a token
+    token_response = login_user_service(db, credentials)
+    return token_response
+
+@router.post("/registration/logout")
+def logout_user(credentials: UserLogout, db: Session = Depends(get_db)):
+    """Logout a user"""
+    logger.info("User logout request")
+    # In a real app, you would invalidate the token here
+    # For now, just returning success
+    return {}
+
+# User endpoints
+@router.get("/me", response_model=UserResponse)
+def get_current_user_data(current_user: User = Depends(get_current_user)):
+    """Get current user's details based on their token"""
+    logger.info(f"Retrieving current user details for ID: {current_user.id}")
+
+    # Return the current user's data extracted from the token
+    logger.info(f"Successfully retrieved current user details for ID: {current_user.id}")
+    return current_user
+
+@router.get("/{id}", response_model=UserResponse)
+def get_user_details(id: str, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    """Get user details by ID"""
+    logger.info(f"Retrieving user details for ID: {id} by user: {current_user.id}")
+
+    # Users can only retrieve their own details, unless they are HR
+    if current_user.id != id and current_user.role != "hr":
+        logger.warning(f"Unauthorized attempt to access user details by user: {current_user.id} for user: {id}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="You can only access your own user details"
+        )
+
+    user = get_user(db, id)
+    if not user:
+        logger.warning(f"User not found for ID: {id}")
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="User not found"
+        )
+
+    logger.info(f"Successfully retrieved user details for ID: {user.id}")
+    return user

backend/config.py

@@ -0,0 +1,38 @@
+from pydantic_settings import BaseSettings
+from typing import Optional
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+class Settings(BaseSettings):
+    # Database Configuration
+    database_url: str = "sqlite:///./assessment_platform.db"
+
+    # Server Configuration
+    host: str = "0.0.0.0"
+    port: int = 8000
+    debug: bool = False
+
+    # Logging Configuration
+    log_level: str = "INFO"
+    log_file: str = "app.log"
+    log_format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+    # JWT Configuration (for future use)
+    secret_key: str = "your-secret-key-here"
+    algorithm: str = "HS256"
+    access_token_expire_minutes: int = 30
+
+    # Application Configuration
+    app_name: str = "AI-Powered Hiring Assessment Platform"
+    app_version: str = "0.1.0"
+    app_description: str = "MVP for managing hiring assessments using AI"
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
+
+# Create a single instance of settings
+settings = Settings()

backend/database/database.py

@@ -0,0 +1,26 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from config import settings
+from logging_config import get_logger
+
+# Create logger for this module
+logger = get_logger(__name__)
+
+# Database setup using SQLAlchemy
+engine = create_engine(
+    settings.database_url, connect_args={"check_same_thread": False}
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def get_db():
+    """Dependency to get database session"""
+    logger.debug("Creating database session")
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        logger.debug("Closing database session")
+        db.close()

backend/docker-compose.yml

@@ -0,0 +1,33 @@
+version: '3.8'
+
+services:
+  backend:
+    build: .
+    ports:
+      - "8000:8000"
+    volumes:
+      - .:/app
+      - app-static-files:/app/static
+      - ./logs:/app/logs
+    environment:
+      - DATABASE_URL=sqlite:///./assessment_platform.db
+      - HOST=0.0.0.0
+      - PORT=8000
+      - DEBUG=True
+      - LOG_LEVEL=INFO
+      - LOG_FILE=app.log
+      - SECRET_KEY=your-secret-key-here
+      - ALGORITHM=HS256
+      - ACCESS_TOKEN_EXPIRE_MINUTES=30
+      - APP_NAME=AI-Powered Hiring Assessment Platform
+      - APP_VERSION=0.1.0
+      - APP_DESCRIPTION=MVP for managing hiring assessments using AI
+    networks:
+      - app-network
+
+volumes:
+  app-static-files:
+
+networks:
+  app-network:
+    driver: bridge

backend/integrations/ai_integration/ai_factory.py

@@ -0,0 +1,78 @@
+from enum import Enum
+from typing import Dict, Type
+from integrations.ai_integration.ai_generator_interface import AIGeneratorInterface
+from integrations.ai_integration.mock_ai_generator import MockAIGenerator
+from integrations.ai_integration.openai_generator import OpenAIGenerator
+from integrations.ai_integration.anthropic_generator import AnthropicGenerator
+from integrations.ai_integration.google_ai_generator import GoogleAIGenerator
+
+
+class AIProvider(Enum):
+    """
+    Enum representing different AI providers that can be used.
+    """
+    MOCK = "mock"
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    GOOGLE = "google"
+
+
+class AIGeneratorFactory:
+    """
+    Factory class for creating AI generator instances.
+    Allows for easy addition of new AI providers without changing existing code.
+    """
+    
+    _providers: Dict[AIProvider, Type[AIGeneratorInterface]] = {}
+    
+    @classmethod
+    def register_provider(cls, provider: AIProvider, generator_class: Type[AIGeneratorInterface]):
+        """
+        Register a new AI provider with the factory.
+        
+        Args:
+            provider: The AI provider enum value
+            generator_class: The class that implements AIGeneratorInterface
+        """
+        cls._providers[provider] = generator_class
+    
+    @classmethod
+    def create_generator(cls, provider: AIProvider) -> AIGeneratorInterface:
+        """
+        Create an instance of the specified AI generator.
+        
+        Args:
+            provider: The AI provider to instantiate
+            
+        Returns:
+            An instance of the requested AI generator
+            
+        Raises:
+            ValueError: If the provider is not registered
+        """
+        if provider not in cls._providers:
+            raise ValueError(f"AI provider {provider} is not registered")
+        
+        generator_class = cls._providers[provider]
+        return generator_class()
+    
+    @classmethod
+    def get_available_providers(cls) -> list:
+        """
+        Get a list of available AI providers.
+        
+        Returns:
+            List of available AI providers
+        """
+        return list(cls._providers.keys())
+
+
+# Register all available providers
+AIGeneratorFactory.register_provider(AIProvider.MOCK, MockAIGenerator)
+AIGeneratorFactory.register_provider(AIProvider.OPENAI, OpenAIGenerator)
+AIGeneratorFactory.register_provider(AIProvider.ANTHROPIC, AnthropicGenerator)
+AIGeneratorFactory.register_provider(AIProvider.GOOGLE, GoogleAIGenerator)
+
+
+# Optional: Create a default provider
+DEFAULT_PROVIDER = AIProvider.MOCK

backend/integrations/ai_integration/ai_generator_interface.py

@@ -0,0 +1,57 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any
+from schemas.assessment import AssessmentQuestion
+
+
+class AIGeneratorInterface(ABC):
+    """
+    Interface for AI question generators.
+    Defines the contract that all AI providers must implement.
+    """
+
+    @abstractmethod
+    def generate_questions(
+        self,
+        title: str,
+        questions_types: List[str],
+        additional_note: str = None,
+        job_info: Dict[str, Any] = None
+    ) -> List[AssessmentQuestion]:
+        """
+        Generate questions based on the assessment title, job information, and specified question types.
+
+        Args:
+            title: The title of the assessment
+            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
+
+        Returns:
+            List of generated AssessmentQuestion objects
+        """
+        pass
+
+    @abstractmethod
+    def score_answer(
+        self,
+        question: AssessmentQuestion,
+        answer_text: str,
+        selected_options: List[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Score an answer based on the question and the provided answer.
+
+        Args:
+            question: The question being answered
+            answer_text: The text of the answer (for text-based questions)
+            selected_options: Selected options (for multiple choice questions)
+
+        Returns:
+            Dictionary containing score information:
+            {
+                'score': float,  # Score between 0 and 1
+                'rationale': str,  # Explanation of the score
+                'correct': bool  # Whether the answer is correct
+            }
+        """
+        pass

backend/integrations/ai_integration/anthropic_generator.py

@@ -0,0 +1,39 @@
+from typing import List, Dict, Any
+from schemas.assessment import AssessmentQuestion
+from integrations.ai_integration.ai_generator_interface import AIGeneratorInterface
+
+
+class AnthropicGenerator(AIGeneratorInterface):
+    """
+    Anthropic Generator implementation.
+    This is a placeholder that will be implemented when integrating with Anthropic API.
+    """
+
+    def generate_questions(
+        self,
+        title: str,
+        questions_types: List[str],
+        additional_note: str = None,
+        job_info: Dict[str, Any] = None
+    ) -> List[AssessmentQuestion]:
+        """
+        Generate questions using Anthropic API.
+        This is a placeholder implementation.
+        """
+        # In a real implementation, this would call the Anthropic API
+        # For now, we'll raise an exception indicating it's not implemented
+        raise NotImplementedError("Anthropic integration not yet implemented")
+
+    def score_answer(
+        self,
+        question: AssessmentQuestion,
+        answer_text: str,
+        selected_options: List[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Score an answer using Anthropic API.
+        This is a placeholder implementation.
+        """
+        # In a real implementation, this would call the Anthropic API
+        # For now, we'll raise an exception indicating it's not implemented
+        raise NotImplementedError("Anthropic answer scoring not yet implemented")

backend/integrations/ai_integration/google_ai_generator.py

@@ -0,0 +1,39 @@
+from typing import List, Dict, Any
+from schemas.assessment import AssessmentQuestion
+from integrations.ai_integration.ai_generator_interface import AIGeneratorInterface
+
+
+class GoogleAIGenerator(AIGeneratorInterface):
+    """
+    Google AI Generator implementation.
+    This is a placeholder that will be implemented when integrating with Google AI API.
+    """
+
+    def generate_questions(
+        self,
+        title: str,
+        questions_types: List[str],
+        additional_note: str = None,
+        job_info: Dict[str, Any] = None
+    ) -> List[AssessmentQuestion]:
+        """
+        Generate questions using Google AI API.
+        This is a placeholder implementation.
+        """
+        # In a real implementation, this would call the Google AI API
+        # For now, we'll raise an exception indicating it's not implemented
+        raise NotImplementedError("Google AI integration not yet implemented")
+
+    def score_answer(
+        self,
+        question: AssessmentQuestion,
+        answer_text: str,
+        selected_options: List[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Score an answer using Google AI API.
+        This is a placeholder implementation.
+        """
+        # In a real implementation, this would call the Google AI API
+        # For now, we'll raise an exception indicating it's not implemented
+        raise NotImplementedError("Google AI answer scoring not yet implemented")

backend/integrations/ai_integration/mock_ai_generator.py

@@ -0,0 +1,378 @@
+import random
+import uuid
+from typing import List, Dict, Any
+from schemas.assessment import AssessmentQuestion, AssessmentQuestionOption
+from schemas.enums import QuestionType
+from integrations.ai_integration.ai_generator_interface import AIGeneratorInterface
+
+
+class MockAIGenerator(AIGeneratorInterface):
+    """
+    Mock AI Generator implementation for testing purposes.
+    Generates questions based on predefined templates and job information.
+    """
+    
+    def generate_questions(
+        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)
+        generated_questions = []
+        
+        for i, q_type in enumerate(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,
+                text=question_text,
+                weight=weight,
+                skill_categories=skill_categories,
+                type=QuestionType(q_type),
+                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:
+        """Generate a question text based on the assessment title, job info and question type."""
+        # Normalize the title to lowercase for processing
+        normalized_title = title.lower()
+        
+        # Use job information if available to enhance question relevance
+        job_title = job_info.get('title', '') if job_info else ''
+        job_description = job_info.get('description', '') if job_info else ''
+        job_seniority = job_info.get('seniority', '') if job_info else ''
+        job_skills = job_info.get('skill_categories', []) if job_info else []
+        
+        # Create a base question depending on the assessment title and job information
+        if "python" in normalized_title or "programming" in normalized_title or "python" in job_title.lower() or "programming" in job_title.lower():
+            base_questions = [
+                f"What is the correct way to declare a variable in {title}?",
+                f"How would you implement a function to solve a problem in {title}?",
+                f"Which of the following is a characteristic of {title}?",
+                f"What is the time complexity of this operation in {title}?",
+                f"In {title}, what is the purpose of this code snippet?",
+                f"What is the output of this {title} code?",
+                f"Which {title} concept is best suited for this scenario?",
+                f"What is the main advantage of using {title} in this context?"
+            ]
+        elif "software" in normalized_title or "engineer" in normalized_title or "software" in job_title.lower() or "engineer" in job_title.lower():
+            base_questions = [
+                f"What is the most efficient approach to design a system for {title}?",
+                f"Which software development principle applies to {title}?",
+                f"How would you optimize the performance of a {title} application?",
+                f"What is the best practice for error handling in {title}?",
+                f"Which testing methodology is most appropriate for {title}?",
+                f"What architectural pattern would you recommend for {title}?",
+                f"How would you ensure scalability in {title}?",
+                f"What security consideration is important for {title}?"
+            ]
+        elif "data" in normalized_title or "analysis" in normalized_title or "data" in job_title.lower() or "analysis" in job_title.lower():
+            base_questions = [
+                f"How would you clean and preprocess data for {title}?",
+                f"Which statistical method is appropriate for {title}?",
+                f"What visualization technique best represents {title}?",
+                f"How would you handle missing values in {title}?",
+                f"What is the correlation between variables in {title}?",
+                f"Which machine learning model is suitable for {title}?",
+                f"How would you validate the results of {title}?",
+                f"What ethical consideration applies to {title}?"
+            ]
+        elif job_skills:  # If job has specific skill categories, use them to generate relevant questions
+            # Join the skills to form a context
+            skills_context = ", ".join(job_skills)
+            base_questions = [
+                f"How would you apply {skills_context} skills in this {title} role?",
+                f"What challenges might you face using {skills_context} in this position?",
+                f"Which {skills_context} techniques are most relevant for this {title}?",
+                f"How would you leverage your {skills_context} experience in this role?",
+                f"What {skills_context} methodologies would you use for this {title}?",
+                f"How do {skills_context} skills contribute to success in this position?",
+                f"What {skills_context} tools would be most effective for this {title}?",
+                f"How would you apply {skills_context} best practices in this role?"
+            ]
+        else:
+            # Generic questions if title doesn't match known patterns
+            base_questions = [
+                f"What is the fundamental concept behind {title}?",
+                f"How would you approach solving a problem in {title}?",
+                f"What are the key characteristics of {title}?",
+                f"What is the main purpose of {title}?",
+                f"Which principle governs {title}?",
+                f"How does {title} differ from similar concepts?",
+                f"What are the advantages of using {title}?",
+                f"What limitations should be considered in {title}?"
+            ]
+        
+        # Select a question based on the question number to ensure variety
+        question_index = (question_number * 7) % len(base_questions)  # Use prime number to create variation
+        question_text = base_questions[question_index]
+        
+        # Add context from additional note if provided
+        if additional_note:
+            question_text += f" ({additional_note})"
+        
+        # Add context from job description if available
+        if job_description:
+            question_text += f" Consider the following job description: {job_description[:100]}..."  # Truncate to avoid overly long questions
+        
+        return question_text
+
+    def _generate_skill_categories(self, title: str, job_info: Dict[str, Any] = None) -> List[str]:
+        """Generate skill categories based on the assessment title and job information."""
+        normalized_title = title.lower()
+        categories = ["general"]
+        
+        # Use job information if available to enhance category relevance
+        job_title = job_info.get('title', '') if job_info else ''
+        job_seniority = job_info.get('seniority', '') if job_info else ''
+        job_skills = job_info.get('skill_categories', []) if job_info else []
+        
+        # Combine title and job title for broader matching
+        combined_title = f"{title} {job_title}".lower()
+        
+        if "python" in combined_title:
+            categories.extend(["python", "programming", "backend"])
+        elif "javascript" in combined_title or "js" in combined_title:
+            categories.extend(["javascript", "programming", "frontend"])
+        elif "react" in combined_title:
+            categories.extend(["react", "javascript", "frontend"])
+        elif "data" in combined_title or "analysis" in combined_title:
+            categories.extend(["data-analysis", "statistics", "visualization"])
+        elif "machine learning" in combined_title or "ml" in combined_title:
+            categories.extend(["machine-learning", "algorithms", "data-science"])
+        elif "devops" in combined_title:
+            categories.extend(["devops", "ci/cd", "infrastructure"])
+        elif "security" in combined_title:
+            categories.extend(["security", "cybersecurity", "vulnerability"])
+        elif "software" in combined_title or "engineer" in combined_title:
+            categories.extend(["software-engineering", "design-patterns", "algorithms"])
+        
+        # Add job-specific skills if available
+        if job_skills:
+            categories.extend(job_skills)
+        
+        # Add seniority-specific categories
+        if job_seniority:
+            if job_seniority == "intern":
+                categories.extend(["learning", "basic-concepts", "mentoring"])
+            elif job_seniority == "junior":
+                categories.extend(["development", "coding", "implementation"])
+            elif job_seniority == "mid":
+                categories.extend(["problem-solving", "architecture", "teamwork"])
+            elif job_seniority == "senior":
+                categories.extend(["leadership", "architecture", "decision-making"])
+        
+        # Add a few more generic categories
+        categories.extend(["problem-solving", "critical-thinking"])
+        
+        # Limit to 5 categories max to prevent overly long lists
+        return list(set(categories))[:5]
+
+    def _generate_multiple_choice_options(self, q_type: str, question_text: str) -> List[AssessmentQuestionOption]:
+        """Generate multiple choice options for a question."""
+        options = []
+        
+        # Generate 3-5 options depending on the question
+        num_options = random.randint(3, 5)
+        
+        for i in range(num_options):
+            option_letter = chr(ord('a') + i)  # 'a', 'b', 'c', etc.
+            
+            # Create option text based on the question
+            if "python" in question_text.lower():
+                option_texts = [
+                    f"Option {option_letter}: This approach uses Python's built-in functions",
+                    f"Option {option_letter}: This solution involves a custom class implementation",
+                    f"Option {option_letter}: This method leverages external libraries",
+                    f"Option {option_letter}: This technique uses recursion",
+                    f"Option {option_letter}: This algorithm has O(n) time complexity",
+                    f"Option {option_letter}: This pattern follows Python best practices"
+                ]
+            elif "software" in question_text.lower() or "design" in question_text.lower():
+                option_texts = [
+                    f"Option {option_letter}: This follows the singleton pattern",
+                    f"Option {option_letter}: This implements the observer pattern",
+                    f"Option {option_letter}: This uses the factory method",
+                    f"Option {option_letter}: This applies the decorator pattern",
+                    f"Option {option_letter}: This utilizes microservices architecture",
+                    f"Option {option_letter}: This employs event-driven design"
+                ]
+            else:
+                option_texts = [
+                    f"Option {option_letter}: This is the correct approach",
+                    f"Option {option_letter}: This is an alternative method",
+                    f"Option {option_letter}: This is a common misconception",
+                    f"Option {option_letter}: This relates to advanced concepts",
+                    f"Option {option_letter}: This is a basic implementation",
+                    f"Option {option_letter}: This is an outdated approach"
+                ]
+            
+            # Select an option text based on the option index
+            option_index = (i * 11) % len(option_texts)  # Use prime number for variation
+            option_text = option_texts[option_index]
+            
+            option = AssessmentQuestionOption(
+                text=option_text,
+                value=option_letter
+            )
+            
+            options.append(option)
+        
+        return options
+
+    def _select_correct_options(self, options: List[AssessmentQuestionOption], q_type: str) -> List[str]:
+        """Select the correct options for a question."""
+        if not options:
+            return []
+
+        # For 'choose_one', select exactly one correct option
+        if q_type == QuestionType.choose_one.value:
+            # Randomly select one option as correct (index 0 to len(options)-1)
+            correct_index = random.randint(0, len(options) - 1)
+            return [options[correct_index].value]
+
+        # For 'choose_many', select 1-2 correct options
+        elif q_type == QuestionType.choose_many.value:
+            # Randomly decide how many correct options (1 or 2)
+            num_correct = random.randint(1, min(2, len(options)))
+
+            # Randomly select indices for correct options
+            correct_indices = random.sample(range(len(options)), num_correct)
+
+            # Return the values of the selected correct options
+            return [options[i].value for i in correct_indices]
+
+        # For other types, return empty list
+        return []
+
+    def score_answer(
+        self,
+        question: AssessmentQuestion,
+        answer_text: str,
+        selected_options: List[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Score an answer based on the question and the provided answer.
+
+        Args:
+            question: The question being answered
+            answer_text: The text of the answer (for text-based questions)
+            selected_options: Selected options (for multiple choice questions)
+
+        Returns:
+            Dictionary containing score information:
+            {
+                'score': float,  # Score between 0 and 1
+                'rationale': str,  # Explanation of the score
+                'correct': bool  # Whether the answer is correct
+            }
+        """
+        # For multiple choice questions - score directly without AI
+        if question.type in [QuestionType.choose_one, QuestionType.choose_many]:
+            if selected_options is None:
+                selected_options = []
+
+            # Check if the selected options match the correct options
+            correct = set(selected_options) == set(question.correct_options)
+
+            if correct:
+                score = 1.0
+                rationale = f"The selected options {selected_options} match the correct options {question.correct_options}."
+            else:
+                score = 0.0
+                rationale = f"The selected options {selected_options} do not match the correct options {question.correct_options}."
+
+            return {
+                'score': score,
+                'rationale': rationale,
+                'correct': correct
+            }
+
+        # For text-based questions - this is where AI evaluation would happen
+        elif question.type == QuestionType.text_based:
+            # For mock implementation, we'll give a score based on whether text is provided
+            if answer_text and answer_text.strip():
+                # In a real implementation, this would use AI to evaluate the quality of the answer
+                # For now, we'll simulate a more nuanced scoring
+                # Consider factors like length, keywords related to the question, etc.
+                score = self._evaluate_text_answer(answer_text, question.text)
+                rationale = f"The text answer was evaluated with score {score}."
+            else:
+                score = 0.0
+                rationale = "No answer was provided."
+
+            return {
+                'score': score,
+                'rationale': rationale,
+                'correct': score > 0.5  # Consider correct if score > 0.5
+            }
+
+        # Default case
+        return {
+            'score': 0.0,
+            'rationale': "Unable to score this type of question.",
+            'correct': False
+        }
+
+    def _evaluate_text_answer(self, answer_text: str, question_text: str) -> float:
+        """
+        Evaluate a text-based answer (simulated AI evaluation).
+        In a real implementation, this would call an AI service to evaluate the answer quality.
+
+        Args:
+            answer_text: The text of the answer provided by the user
+            question_text: The text of the question being answered
+
+        Returns:
+            Score between 0 and 1
+        """
+        # Simple heuristics for mock evaluation
+        score = 0.0
+
+        # Check if answer is substantial (not just a few words)
+        if len(answer_text.split()) >= 5:  # At least 5 words
+            score += 0.3
+
+        # Check if answer contains relevant keywords from the question
+        question_keywords = set(question_text.lower().split())
+        answer_words = set(answer_text.lower().split())
+        common_words = question_keywords.intersection(answer_words)
+
+        if len(common_words) > 0:
+            score += 0.2  # Bonus for mentioning relevant terms
+
+        # Additional bonus for longer, more detailed answers
+        if len(answer_text) > 100:
+            score += 0.2
+
+        # Cap the score at 1.0
+        return min(score, 1.0)

backend/integrations/ai_integration/openai_generator.py

@@ -0,0 +1,39 @@
+from typing import List, Dict, Any
+from schemas.assessment import AssessmentQuestion
+from integrations.ai_integration.ai_generator_interface import AIGeneratorInterface
+
+
+class OpenAIGenerator(AIGeneratorInterface):
+    """
+    OpenAI Generator implementation.
+    This is a placeholder that will be implemented when integrating with OpenAI API.
+    """
+
+    def generate_questions(
+        self,
+        title: str,
+        questions_types: List[str],
+        additional_note: str = None,
+        job_info: Dict[str, Any] = None
+    ) -> List[AssessmentQuestion]:
+        """
+        Generate questions using OpenAI API.
+        This is a placeholder implementation.
+        """
+        # In a real implementation, this would call the OpenAI API
+        # For now, we'll raise an exception indicating it's not implemented
+        raise NotImplementedError("OpenAI integration not yet implemented")
+
+    def score_answer(
+        self,
+        question: AssessmentQuestion,
+        answer_text: str,
+        selected_options: List[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Score an answer using OpenAI API.
+        This is a placeholder implementation.
+        """
+        # In a real implementation, this would call the OpenAI API
+        # For now, we'll raise an exception indicating it's not implemented
+        raise NotImplementedError("OpenAI answer scoring not yet implemented")

backend/logging_config.py

@@ -0,0 +1,37 @@
+import logging
+import logging.config
+from config import settings
+import os
+
+def setup_logging():
+    """Setup logging configuration"""
+    # Create logs directory if it doesn't exist
+    log_dir = os.path.dirname(settings.log_file)
+    if log_dir and not os.path.exists(log_dir):
+        os.makedirs(log_dir)
+    
+    # Configure logging
+    logging.basicConfig(
+        level=getattr(logging, settings.log_level.upper()),
+        format=settings.log_format,
+        handlers=[
+            logging.FileHandler(settings.log_file),
+            logging.StreamHandler()  # Also log to console
+        ]
+    )
+    
+    # Create a logger for the application
+    logger = logging.getLogger(__name__)
+    logger.info(f"Logging initialized with level: {settings.log_level}")
+    
+    return logger
+
+# Initialize the logger
+logger = setup_logging()
+
+def get_logger(name: str = None):
+    """Get a logger instance with the specified name"""
+    if name:
+        return logging.getLogger(name)
+    else:
+        return logger

backend/main.py

@@ -0,0 +1,54 @@
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+import os
+
+# Import from our modules
+from models import Base
+from database.database import engine
+from api.routes import router as root_router
+from api.user_routes import router as user_router
+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
+
+# Create logger for this module
+logger = get_logger(__name__)
+
+@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}")
+    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,
+    version=settings.app_version,
+    lifespan=lifespan
+)
+
+# Include API routes
+app.include_router(root_router)
+app.include_router(user_router)
+app.include_router(job_router)
+app.include_router(assessment_router)
+app.include_router(application_router)
+
+logger.info("Application routes registered")
+
+if __name__ == "__main__":
+    import uvicorn
+    logger.info(f"Starting server on {settings.host}:{settings.port}")
+    uvicorn.run(
+        app,
+        host=settings.host,
+        port=settings.port,
+    )

backend/models/__init__.py

@@ -0,0 +1,7 @@
+from .base import Base
+from .user import User
+from .job import Job
+from .assessment import Assessment
+from .application import Application
+
+__all__ = ["Base", "User", "Job", "Assessment", "Application"]

backend/models/application.py

@@ -0,0 +1,12 @@
+from sqlalchemy import Column, String, Text, ForeignKey
+from .base import Base
+import uuid
+
+class Application(Base):
+    __tablename__ = "applications"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()), index=True)
+    job_id = Column(String, ForeignKey("jobs.id"), nullable=False)
+    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

backend/models/assessment.py

@@ -0,0 +1,61 @@
+from sqlalchemy import Column, String, Integer, Boolean, Text, ForeignKey, CheckConstraint
+from .base import Base
+import uuid
+import json
+from pydantic import ValidationError
+from typing import Dict, Any
+
+class Assessment(Base):
+    __tablename__ = "assessments"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()), index=True)
+    job_id = Column(String, ForeignKey("jobs.id"), nullable=False)
+    title = Column(String, nullable=False)
+    duration = Column(Integer)  # in seconds
+    passing_score = Column(Integer)  # range 20-80
+    questions = Column(Text)  # Stored as JSON string
+    active = Column(Boolean, default=True)
+
+    # Add constraint to ensure passing_score is in range 20-80
+    __table_args__ = (
+        CheckConstraint(passing_score >= 20, name='passing_score_min'),
+        CheckConstraint(passing_score <= 80, name='passing_score_max'),
+    )
+
+    def validate_questions(self) -> bool:
+        """Validate the questions JSON structure"""
+        try:
+            if self.questions:
+                parsed_questions = json.loads(self.questions)
+                if not isinstance(parsed_questions, list):
+                    return False
+
+                # Validate each question
+                for question in parsed_questions:
+                    if not self._validate_single_question(question):
+                        return False
+                return True
+            return True
+        except (json.JSONDecodeError, TypeError):
+            return False
+
+    def _validate_single_question(self, question: Dict[str, Any]) -> bool:
+        """Validate a single question structure"""
+        required_fields = {'id', 'text', 'weight', 'skill_categories', 'type'}
+        if not all(field in question for field in required_fields):
+            return False
+
+        # Validate weight is in range 1-5
+        if not isinstance(question['weight'], int) or question['weight'] < 1 or question['weight'] > 5:
+            return False
+
+        # Validate skill_categories is a list
+        if not isinstance(question['skill_categories'], list):
+            return False
+
+        # Validate type is one of the allowed types
+        allowed_types = {'choose_one', 'choose_many', 'text_based'}
+        if question['type'] not in allowed_types:
+            return False
+
+        return True

backend/models/base.py

@@ -0,0 +1,3 @@
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()

backend/models/job.py

@@ -0,0 +1,31 @@
+from sqlalchemy import Column, String, Boolean, Text, CheckConstraint
+from .base import Base
+import uuid
+import json
+from typing import List, Optional
+
+class Job(Base):
+    __tablename__ = "jobs"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()), index=True)
+    title = Column(String, nullable=False)
+    seniority = Column(String, nullable=False)  # intern, junior, mid, senior
+    description = Column(Text)
+    skill_categories = Column(String)  # Stored as JSON string
+    active = Column(Boolean, default=True)
+
+    # Add constraint to ensure seniority is valid
+    __table_args__ = (CheckConstraint(seniority.in_(['intern', 'junior', 'mid', 'senior']), name='valid_seniority'),)
+
+    def validate_skill_categories(self) -> bool:
+        """Validate the skill_categories JSON structure"""
+        try:
+            if self.skill_categories:
+                parsed_categories = json.loads(self.skill_categories)
+                if not isinstance(parsed_categories, list):
+                    return False
+                # Validate that all items in the list are strings
+                return all(isinstance(cat, str) for cat in parsed_categories)
+            return True
+        except (json.JSONDecodeError, TypeError):
+            return False

backend/models/user.py

@@ -0,0 +1,42 @@
+from sqlalchemy import Column, String, CheckConstraint
+from .base import Base
+import uuid
+from utils.password_utils import get_password_hash, verify_password
+import re
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()), index=True)
+    first_name = Column(String, nullable=False)
+    last_name = Column(String, nullable=False)
+    email = Column(String, unique=True, index=True, nullable=False)
+    password = Column(String, nullable=False)
+    role = Column(String, nullable=False)  # 'hr' or 'applicant'
+
+    # Add constraint to ensure role is either 'hr' or 'applicant'
+    __table_args__ = (CheckConstraint(role.in_(['hr', 'applicant']), name='valid_role'),)
+
+    def set_password(self, password: str):
+        """Hash and set the user's password"""
+        self.password = get_password_hash(password)
+
+    def check_password(self, password: str) -> bool:
+        """Check if the provided password matches the stored hash"""
+        return verify_password(password, self.password)
+
+    def validate_name(self, name: str) -> bool:
+        """Validate that the name contains only letters, spaces, hyphens, and apostrophes"""
+        if not name:
+            return False
+        # Allow letters, spaces, hyphens, and apostrophes, with length between 1 and 50
+        pattern = r"^[a-zA-Z\s\-']{1,50}$"
+        return bool(re.match(pattern, name.strip()))
+
+    def validate_first_name(self) -> bool:
+        """Validate the first name"""
+        return self.validate_name(self.first_name)
+
+    def validate_last_name(self) -> bool:
+        """Validate the last name"""
+        return self.validate_name(self.last_name)

backend/requirements-dev.txt

@@ -0,0 +1,6 @@
+pytest>=7.0.0
+pytest-cov>=4.0.0
+httpx>=0.23.0
+pytest-asyncio>=0.20.0
+factory-boy>=3.2.0
+Faker>=13.0.0

backend/requirements-test.txt

@@ -0,0 +1,6 @@
+# Testing requirements
+pytest>=7.0.0
+pytest-cov>=4.0.0
+pytest-mock>=3.10.0
+factory-boy>=3.2.0
+faker>=18.0.0

backend/requirements.md

@@ -0,0 +1,98 @@
+1. System Requirements — MVP for AI-Powered Hiring Assessment Platform
+1.1 Overview
+A platform for managing hiring assessments using AI, serving two primary user types: 1. HR (Human Resources) 2. Candidate
+Goal: Enable HR to create smart assessments, manage them, and review results easily, while allowing candidates to take assessments and review their results.
+1.2 Primary Users
+1.2.1 HR
+A user responsible for creating and managing assessments, questions, and reviewing candidate results.
+1.2.2 Candidate
+A user who takes assessments and reviews their previous results.
+2. Functional Requirements — HR
+2.1 Authentication and Account Management
+•	HR login using email and password.
+2.2 Job Roles and Assessment Management
+•	Create a new assessment.
+•	Enter assessment information:
+1.	Job Title
+2.	Experience Level
+3.	Required Skills
+4.	Job Description
+5.	Number of Questions
+6.	Assessment Description (optional) to be displayed to the candidate
+2.3 Creating Questions Using AI
+•	Create questions through AI chat based on job information.
+•	Save questions in a question bank linked to the assessment.
+•	Edit questions manually.
+•	Edit a question using AI (rewording, difficulty adjustment, clarity improvement).
+2.4 Managing Question Properties
+•	Mark a question as:
+1.	Failing Question / Knockout
+•	Add tags to questions to be used as evaluation criteria (e.g., Python, Communication, SQL).
+•	Set weight or importance for each question.
+2.5 Assessment Evaluation and Review
+•	Display assessment results in a table containing:
+1.	Candidate Name
+2.	Assessment Date
+3.	Time Taken to Complete
+4.	Final Numeric Score
+5.	Pass/Fail status based on:
+	Required level
+	Knockout questions
+6.	Candidate score per tag (Tag-based Scores)
+•	Review a specific candidate’s answers for each question.
+•	Display a summary view:
+1.	Average Scores
+2.	Pass Rate
+3.	Key Strengths and Weaknesses (from AI)
+•	Set a score/rating for each question manually or with AI assistance.
+2.6 Retrieving and Managing Assessments
+•	Retrieve specific assessment information (questions, settings, results).
+•	HR can edit any question and use AI for assistance.
+2.7 Sharing Assessments
+•	Generate a unique link for the assessment.
+•	Enable/disable the assessment link.
+3. Functional Requirements — Candidate
+3.1 Authentication and Account Management
+•	Candidate login (email + password).
+3.2 Taking the Assessment
+•	Access the assessment via link.
+•	Display assessment instructions.
+•	Answer the questions.
+•	Submit the assessment upon completion.
+3.3 Reviewing Results
+•	Display previous assessment results.
+•	Show overall score.
+•	Display general feedback (optional).
+4. Evaluation
+•	Each question has a maximum score.
+•	Questions can be marked as Knockout.
+•	For Knockout questions:
+1.	Candidate must achieve ≥ 50% of the question score to pass the assessment.
+•	Final score = sum of all question scores.
+4.1 AI Evaluation
+•	The system sends candidate answers to AI for evaluation.
+•	AI returns:
+1.	Suggested score for each question.
+2.	Brief rationale/feedback (optional in MVP).
+•	HR can:
+1.	Modify any question score.
+2.	Accept or ignore AI evaluation.
+4.2 Language
+•	The system interface and questions are in English only.
+4.3 Single HR
+•	Only one HR exists (no multi-company or multi-HR support in MVP).
+5. MVP Core Requirements
+5.1 Question Types
+•	Text Answer questions
+•	True / False questions
+•	Multiple Choice questions
+5.2 Evaluation
+•	Support manual evaluation by HR.
+•	Support AI evaluation suggestion (final decision by HR).
+5.3 Permissions
+•	HR can only see assessments they created.
+•	Candidate can only see their own assessments.
+6. MVP Assumptions
+•	No multiple HR roles (each HR is independent).
+•	No company/team system in the first version.
+•	No advanced anti-cheating mechanisms (camera or tracking).

backend/run_tests.py

@@ -0,0 +1,36 @@
+"""
+Test Runner for AI-Powered Hiring Assessment Platform
+This script runs all tests in the test suite.
+"""
+
+import unittest
+import sys
+import os
+
+# Add the backend directory to the path so imports work
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '.'))
+
+def run_tests():
+    """Run all tests in the test suite."""
+    print("Running comprehensive test suite for AI-Powered Hiring Assessment Platform...")
+    
+    # Discover and run all tests in the tests directory
+    loader = unittest.TestLoader()
+    start_dir = 'tests'
+    suite = loader.discover(start_dir, pattern='test_*.py')
+    
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(suite)
+    
+    # Print summary
+    print(f"\nTests run: {result.testsRun}")
+    print(f"Failures: {len(result.failures)}")
+    print(f"Errors: {len(result.errors)}")
+    print(f"Success: {result.wasSuccessful()}")
+    
+    return result.wasSuccessful()
+
+
+if __name__ == '__main__':
+    success = run_tests()
+    sys.exit(0 if success else 1)

backend/schemas/__init__.py

@@ -0,0 +1,11 @@
+from .user import UserBase, UserCreate, UserUpdate, UserResponse, UserLogin, UserLogout, TokenResponse
+from .job import JobBase, JobCreate, JobUpdate, JobResponse, JobListResponse
+from .assessment import AssessmentBase, AssessmentCreate, AssessmentUpdate, AssessmentResponse, AssessmentListResponse, AssessmentDetailedResponse, AssessmentRegenerate
+from .application import ApplicationBase, ApplicationCreate, ApplicationUpdate, ApplicationResponse, ApplicationListResponse, ApplicationDetailedResponse, ApplicationDetailedListResponse
+
+__all__ = [
+    "UserBase", "UserCreate", "UserUpdate", "UserResponse", "UserLogin", "UserLogout", "TokenResponse",
+    "JobBase", "JobCreate", "JobUpdate", "JobResponse", "JobListResponse",
+    "AssessmentBase", "AssessmentCreate", "AssessmentUpdate", "AssessmentResponse", "AssessmentListResponse", "AssessmentDetailedResponse", "AssessmentRegenerate",
+    "ApplicationBase", "ApplicationCreate", "ApplicationUpdate", "ApplicationResponse", "ApplicationListResponse", "ApplicationDetailedResponse", "ApplicationDetailedListResponse"
+]

backend/schemas/application.py

@@ -0,0 +1,67 @@
+from typing import Optional, List
+from pydantic import BaseModel, Field
+from .base import BaseSchema
+from .enums import QuestionType
+
+class ApplicationAnswer(BaseModel):
+    question_id: str = Field(..., min_length=1)
+    text: Optional[str] = Field(None, max_length=5000)
+    options: Optional[List[str]] = []
+
+class ApplicationUser(BaseModel):
+    id: str
+    first_name: str
+    last_name: str
+    email: str
+
+class ApplicationQuestion(BaseModel):
+    id: str = Field(..., min_length=1)
+    text: str = Field(..., min_length=1, max_length=1000)
+    weight: int = Field(..., ge=1, le=5)  # range 1-5
+    skill_categories: List[str] = Field(..., min_items=1)
+    type: QuestionType
+    options: Optional[List[dict]] = []  # Using dict for simplicity
+    correct_options: Optional[List[str]] = []
+
+class ApplicationAnswerWithQuestion(ApplicationAnswer):
+    question_text: str = Field(..., min_length=1, max_length=1000)
+    weight: int = Field(..., ge=1, le=5)  # range 1-5
+    skill_categories: List[str] = Field(..., min_items=1)
+    type: QuestionType
+    options: Optional[List[dict]] = []
+    correct_options: Optional[List[str]] = []
+    rationale: str = Field(..., min_length=1, max_length=1000)
+
+class ApplicationBase(BaseSchema):
+    job_id: str = Field(..., min_length=1)
+    assessment_id: str = Field(..., min_length=1)
+    user_id: str = Field(..., min_length=1)
+    answers: List[ApplicationAnswer] = Field(..., min_items=1)
+
+class ApplicationCreate(ApplicationBase):
+    pass
+
+class ApplicationUpdate(BaseModel):
+    answers: Optional[List[ApplicationAnswer]] = Field(None, min_items=1)
+
+class ApplicationResponse(ApplicationBase):
+    id: str
+    score: Optional[float] = None
+    passing_score: Optional[float] = None
+
+    class Config:
+        from_attributes = True
+
+class ApplicationDetailedResponse(ApplicationResponse):
+    user: ApplicationUser
+    answers: List[ApplicationAnswerWithQuestion]
+
+class ApplicationListResponse(BaseModel):
+    count: int
+    total: int
+    data: List[ApplicationResponse]
+
+class ApplicationDetailedListResponse(BaseModel):
+    count: int
+    total: int
+    data: List[ApplicationResponse]

backend/schemas/assessment.py

@@ -0,0 +1,56 @@
+from typing import Optional, List
+from pydantic import BaseModel, Field
+from .base import BaseSchema
+from .enums import QuestionType
+
+class AssessmentQuestionOption(BaseModel):
+    text: str
+    value: str
+
+class AssessmentQuestion(BaseModel):
+    id: str
+    text: str
+    weight: int = Field(..., ge=1, le=5)  # range 1-5
+    skill_categories: List[str]
+    type: QuestionType
+    options: Optional[List[AssessmentQuestionOption]] = []
+    correct_options: Optional[List[str]] = []
+
+class AssessmentBase(BaseSchema):
+    title: str = Field(..., min_length=1, max_length=200)
+    duration: Optional[int] = Field(None, ge=1)  # Duration in seconds, if provided should be positive
+    passing_score: int = Field(..., ge=20, le=80)  # range 20-80
+    questions: Optional[List[AssessmentQuestion]] = []
+    active: bool = True
+
+class AssessmentCreate(BaseModel):
+    title: str = Field(..., min_length=1, max_length=200)
+    passing_score: int = Field(..., ge=20, le=80)  # range 20-80
+    questions_types: List[QuestionType]  # array of enum(choose_one, choose_many, text_based)
+    additional_note: Optional[str] = Field(None, max_length=500)
+
+class AssessmentUpdate(BaseModel):
+    title: Optional[str] = Field(None, min_length=1, max_length=200)
+    duration: Optional[int] = Field(None, ge=1)  # Duration in seconds, if provided should be positive
+    passing_score: Optional[int] = Field(None, ge=20, le=80)  # range 20-80
+    questions: Optional[List[AssessmentQuestion]] = None
+    active: Optional[bool] = None
+
+class AssessmentRegenerate(BaseModel):
+    questions_types: Optional[List[QuestionType]] = None  # array of enum(choose_one, choose_many, text_based)
+    additional_note: Optional[str] = Field(None, max_length=500)
+
+class AssessmentResponse(AssessmentBase):
+    id: str
+    questions_count: int = 0
+
+    class Config:
+        from_attributes = True
+
+class AssessmentListResponse(BaseModel):
+    count: int
+    total: int
+    data: List[AssessmentResponse]
+
+class AssessmentDetailedResponse(AssessmentResponse):
+    questions: List[AssessmentQuestion]

backend/schemas/base.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+class BaseSchema(BaseModel):
+    class Config:
+        from_attributes = True

backend/schemas/candidate_assessment.py

@@ -0,0 +1,28 @@
+from typing import Optional
+from pydantic import BaseModel
+from datetime import datetime
+from .base import BaseSchema
+
+class CandidateAssessmentBase(BaseSchema):
+    candidate_id: int
+    assessment_id: int
+    status: str = 'not_started'  # 'not_started', 'in_progress', 'completed'
+    total_score: Optional[int] = None
+
+class CandidateAssessmentCreate(CandidateAssessmentBase):
+    candidate_id: int
+    assessment_id: int
+
+class CandidateAssessmentUpdate(BaseModel):
+    status: Optional[str] = None
+    total_score: Optional[int] = None
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+
+class CandidateAssessmentInDB(CandidateAssessmentBase):
+    id: int
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True

backend/schemas/enums.py

@@ -0,0 +1,21 @@
+from enum import Enum
+
+class UserRole(str, Enum):
+    hr = "hr"
+    applicant = "applicant"
+
+class JobSeniority(str, Enum):
+    intern = "intern"
+    junior = "junior"
+    mid = "mid"
+    senior = "senior"
+
+class QuestionType(str, Enum):
+    choose_one = "choose_one"
+    choose_many = "choose_many"
+    text_based = "text_based"
+
+class SortByOptions(str, Enum):
+    min = "min"
+    max = "max"
+    created_at = "created_at"

backend/schemas/job.py

@@ -0,0 +1,35 @@
+from typing import Optional, List
+from pydantic import BaseModel, Field
+from .base import BaseSchema
+from .enums import JobSeniority
+
+class JobBase(BaseSchema):
+    title: str = Field(..., min_length=1, max_length=200)
+    seniority: JobSeniority
+    description: Optional[str] = Field(None, max_length=1000)
+    skill_categories: Optional[List[str]] = []
+    active: bool = True
+
+class JobCreate(JobBase):
+    title: str = Field(..., min_length=1, max_length=200)
+    seniority: JobSeniority
+    description: Optional[str] = Field(None, max_length=1000)
+
+class JobUpdate(BaseModel):
+    title: Optional[str] = Field(None, min_length=1, max_length=200)
+    seniority: Optional[JobSeniority] = None
+    description: Optional[str] = Field(None, max_length=1000)
+    skill_categories: Optional[List[str]] = None
+    active: Optional[bool] = None
+
+class JobResponse(JobBase):
+    id: str
+    applicants_count: int = 0
+
+    class Config:
+        from_attributes = True
+
+class JobListResponse(BaseModel):
+    count: int
+    total: int
+    data: List[JobResponse]

backend/schemas/question.py

@@ -0,0 +1,30 @@
+from typing import Optional
+from pydantic import BaseModel
+from datetime import datetime
+from .base import BaseSchema
+
+class QuestionBase(BaseSchema):
+    assessment_id: int
+    question_text: str
+    question_type: str  # 'text', 'true_false', 'multiple_choice'
+    is_knockout: bool = False
+    weight: int = 1
+    max_score: int = 10
+
+class QuestionCreate(QuestionBase):
+    question_text: str
+    question_type: str
+
+class QuestionUpdate(BaseModel):
+    question_text: Optional[str] = None
+    question_type: Optional[str] = None
+    is_knockout: Optional[bool] = None
+    weight: Optional[int] = None
+    max_score: Optional[int] = None
+
+class QuestionInDB(QuestionBase):
+    id: int
+    created_at: datetime
+
+    class Config:
+        from_attributes = True