Automated Action 27c9268a6a Implement HR platform backend with FastAPI and SQLite
- Set up project structure with FastAPI framework
- Create database models for users, employees, departments, and job titles
- Implement JWT authentication and authorization system
- Set up SQLite database with SQLAlchemy ORM
- Add Alembic migrations for database versioning
- Create CRUD API endpoints for employee management
- Implement category-based search functionality
- Add OpenAPI documentation and health check endpoint
- Update README with comprehensive setup and usage instructions
2025-06-03 01:18:41 +00:00

5.9 KiB

HR Platform Backend

A comprehensive HR platform backend built with FastAPI and SQLite, providing employee management, authentication, and category-based search functionality.

Features

  • Authentication & Authorization: JWT-based authentication system with user roles
  • Employee Management: Complete CRUD operations for employees
  • Department Management: Organize employees by departments
  • Job Title Management: Manage job positions and titles
  • Category-Based Search: Advanced search functionality by skills, categories, departments, and more
  • OpenAPI Documentation: Interactive API documentation with Swagger UI and ReDoc
  • Health Check Endpoint: Monitor the health of the API and database

Tech Stack

  • Framework: FastAPI
  • Database: SQLite
  • ORM: SQLAlchemy
  • Migrations: Alembic
  • Authentication: JWT (JSON Web Tokens)
  • API Documentation: OpenAPI (Swagger and ReDoc)

Project Structure

.
├── alembic.ini              # Alembic configuration
├── app                      # Main application package
│   ├── api                  # API endpoints
│   │   ├── deps.py          # API dependencies
│   │   ├── routes.py        # API router
│   │   └── v1               # API version 1 endpoints
│   ├── core                 # Core application modules
│   │   ├── config.py        # Application configuration
│   │   └── security.py      # Security utilities
│   ├── crud                 # CRUD operations
│   ├── db                   # Database setup
│   │   ├── base.py          # Base models import
│   │   ├── base_class.py    # Base model class
│   │   ├── init_db.py       # Database initialization
│   │   └── session.py       # Database session
│   ├── models               # SQLAlchemy models
│   └── schemas              # Pydantic schemas
├── main.py                  # Application entry point
├── migrations               # Alembic migrations
│   ├── env.py               # Migration environment
│   ├── script.py.mako       # Migration script template
│   └── versions             # Migration versions
├── openapi.json             # Generated OpenAPI schema
├── openapi_schema.py        # Script to generate OpenAPI schema
└── requirements.txt         # Python dependencies

Getting Started

Prerequisites

  • Python 3.8 or higher
  • pip (Python package installer)

Installation

  1. Clone the repository:

    git clone <repository-url>
    cd hrplatformbackend
    
  2. Install the dependencies:

    pip install -r requirements.txt
    
  3. Set environment variables (optional, defaults are provided):

    export SECRET_KEY="your-secret-key"
    export FIRST_SUPERUSER="admin@example.com"
    export FIRST_SUPERUSER_PASSWORD="admin123"
    

Running Migrations

Run Alembic migrations to set up the database schema:

alembic upgrade head

Running the Application

Start the FastAPI server:

uvicorn main:app --host 0.0.0.0 --port 8000 --reload

The API will be available at http://localhost:8000

API Documentation

Once the server is running, you can access the interactive API documentation:

Usage

Authentication

  1. Register a new user:

    curl -X POST "http://localhost:8000/api/v1/auth/register" \
      -H "Content-Type: application/json" \
      -d '{"email": "user@example.com", "password": "password123", "full_name": "Example User"}'
    
  2. Login to get access token:

    curl -X POST "http://localhost:8000/api/v1/auth/login" \
      -H "Content-Type: application/x-www-form-urlencoded" \
      -d "username=user@example.com&password=password123"
    
  3. Use the token for authenticated requests:

    curl -X GET "http://localhost:8000/api/v1/users/me" \
      -H "Authorization: Bearer YOUR_ACCESS_TOKEN"
    

Employee Management

  1. Create a new employee:

    curl -X POST "http://localhost:8000/api/v1/employees/" \
      -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "first_name": "John",
        "last_name": "Doe",
        "email": "john.doe@example.com",
        "hire_date": "2023-01-15",
        "department_id": "department_id_here",
        "job_title_id": "job_title_id_here"
      }'
    
  2. Search employees by category:

    curl -X GET "http://localhost:8000/api/v1/employees/search/?categories=IT&skills=Python&department_id=dept_id" \
      -H "Authorization: Bearer YOUR_ACCESS_TOKEN"
    

Environment Variables

Variable Description Default Value
PROJECT_NAME Name of the project HR Platform API
SECRET_KEY Secret key for JWT encoding Auto-generated
ACCESS_TOKEN_EXPIRE_MINUTES JWT token expiration time in minutes 11520 (8 days)
FIRST_SUPERUSER Email for the initial admin user admin@example.com
FIRST_SUPERUSER_PASSWORD Password for the initial admin user admin123
SQLALCHEMY_DATABASE_URI Database connection URI sqlite:////app/storage/db/db.sqlite

License

This project is licensed under the MIT License - see the LICENSE file for details.