This repository contains the Django-powered REST API backend for the SecCodeSmith portfolio website. It provides endpoints for blog posts, project showcases, image properties, and static page content (About, Contact, Skills, Footer Links).

• About
• Features
• Tech Stack
• Requirements
• Quick Start
• Installation
• Configuration
• Running the Server
• Testing
• Code Quality
• Docker Support
• API Reference
  • General API
  • Blog API
  • Project API
  • Images API
• Contributing
• CI/CD Pipeline
• License
• Contact

SecCodeSmith Backend serves as the data layer for the portfolio site, supplying JSON over REST endpoints that the front-end consumes for dynamic content. The API is built with Django and Django REST Framework, providing a robust and scalable foundation for the portfolio website.

• 🔥 Blog Posts: List, paginate, and count pages of blog entries
• 🚀 Project Showcase: List projects, view details, and filter by category
• 🖼️ Image Properties: Serve metadata for portfolio images
• 📄 Static Pages: Endpoints for About, Contact, Skills, and Footer Links content
• 🔒 CSRF Support: Retrieve CSRF tokens for secure front-end forms
• 👨‍💼 Admin Interface: Built-in Django admin at /admin/
• 🧪 Comprehensive Testing: Unit tests with pytest and Django TestCase
• 🔍 Code Quality: Automated linting, formatting, and security checks
• 🐳 Docker Support: Containerized deployment ready
• ⚡ Caching: Redis-based caching for improved performance

• 🐍 Python 3.10+
• 🌐 Django 5.2.1
• 📡 Django REST Framework 3.16.0
• 🗃️ PostgreSQL (Production) / SQLite (Development)
• 🔴 Redis for caching
• 🧪 pytest for testing
• 🔍 flake8, black, isort for code quality
• 🛡️ bandit, safety for security scanning
• 🐳 Docker for containerization

• Python 3.10 or later
• pip (Python package installer)
• Redis (for caching)
• PostgreSQL (optional, for production)

Get up and running in less than 5 minutes:

Linux/macOS:

# Clone the repository
git clone https://github.com/SecCodeSmith/SecCodeSmith-backend.git
cd SecCodeSmith-backend

# Make script executable and setup
chmod +x dev.sh
./dev.sh setup

# Start the server
./dev.sh runserver

Windows:

# Clone the repository
git clone https://github.com/SecCodeSmith/SecCodeSmith-backend.git
cd SecCodeSmith-backend

# Setup environment
dev.bat setup

# Start the server
dev.bat runserver

Using Make (Linux/macOS):

# Setup development environment
make setup

# Start the server
make runserver

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

This project includes convenient development scripts:

• Linux/macOS: ./dev.sh [command]
• Windows: dev.bat [command]
• Make: make [target] (Linux/macOS only)

Available commands:

• setup - Complete development environment setup
• test - Run test suite
• lint - Run code quality checks
• format - Format code with black and isort
• runserver - Start Django development server
• migrate - Run database migrations
• security - Run security scans

git clone https://github.com/SecCodeSmith/SecCodeSmith-backend.git
cd SecCodeSmith-backend

Linux/macOS:

python -m venv .venv
source .venv/bin/activate

Windows:

python -m venv .venv
.venv\Scripts\activate

pip install --upgrade pip
pip install -r requirements.txt

Create a .env file in the project root:

# Django Settings
SECRET_KEY=your_super_secret_key_here
DEBUG=True
ALLOWED_HOSTS=localhost,127.0.0.1

# Database (Optional - defaults to SQLite)
DATABASE_TYPE=sqlite  # or 'pgsql' for PostgreSQL
DATABASE_USER=postgres
DATABASE_PASSWORD=your_password
DATABASE_HOST=localhost
DATABASE_PORT=5432
DATABASE_NAME=seccodesmithbackend

# Redis (Optional - uses fakeredis for development)
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_DB=0

# Email (Optional)
EMAIL_HOST=smtp.gmail.com
EMAIL_USER=your_email@gmail.com
EMAIL_PASSWORD=your_app_password
EMAIL_USE_TLS=True
EMAIL_SMTP_PORT=587

python manage.py migrate

python manage.py createsuperuser

The project uses environment variables for configuration via django-environ. Create a .env file to override default settings:

SQLite (Default - Development):

DATABASE_TYPE=sqlite

PostgreSQL (Production):

DATABASE_TYPE=pgsql
DATABASE_USER=postgres
DATABASE_PASSWORD=your_password
DATABASE_HOST=localhost
DATABASE_PORT=5432
DATABASE_NAME=seccodesmithbackend

Development (FakeRedis): No configuration needed - uses in-memory caching.

Production (Redis):

REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_DB=0
REDIS_PASSWORD=your_redis_password

python manage.py runserver

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

• API Root: http://127.0.0.1:8000/api/
• Admin Panel: http://127.0.0.1:8000/admin/
• Blog API: http://127.0.0.1:8000/blog-api/
• Project API: http://127.0.0.1:8000/project-api/
• Images API: http://127.0.0.1:8000/img/

# Using pytest (recommended)
pytest

# Using Django test runner
python manage.py test

# Test specific app
pytest api/test.py

# Test specific test class
pytest api/test.py::SkillCardsViewTests

# Test with verbose output
pytest -v

# Test with coverage
pytest --cov=.

Tests are configured to use:

• In-memory SQLite database
• Local memory cache
• Isolated test environment

This project maintains high code quality through automated tools:

# Check code style
flake8 .

# Format code
black .

# Sort imports
isort .

# Run all checks
flake8 . && black --check . && isort --check-only .

# Scan for security issues
bandit -r .

# Check for vulnerable dependencies
safety check

# Build the image
docker build -t seccodesmithbackend .

# Run the container
docker run -p 8000:8000 seccodesmithbackend

# Start all services
docker-compose up -d

# View logs
docker-compose logs -f

# Stop services
docker-compose down

This project is optimized for Visual Studio Code with comprehensive configuration:

1. Open the workspace: Use SecCodeSmith-backend.code-workspace
2. Install recommended extensions: VS Code will prompt you automatically
3. Select Python interpreter: Choose .venv/bin/python when prompted

• Debugging: Ready-to-use debug configurations for Django
• Testing: Integrated pytest runner with coverage
• Linting: Automated code quality checks
• Formatting: Auto-format on save with Black
• Tasks: One-click Django commands (F1 → "Tasks: Run Task")

• Django: Run Server - Start development server with debugging
• Django: Run Tests - Run test suite with debugging
• Django: Shell - Open Django shell with debugging
• Django: Migrate - Run migrations
• Django: Make Migrations - Create new migrations

Access via Ctrl+Shift+P → "Tasks: Run Task":

• Django: Run Server
• Django: Run Tests (with coverage)
• Code Quality: Lint/Format
• Security: Scan with Bandit
• Install Dependencies

Base path: /api/

Base path: /blog-api/

Base path: /project-api/

Base path: /img/

We welcome contributions! Please follow these steps:

git clone https://github.com/your-username/SecCodeSmith-backend.git
cd SecCodeSmith-backend

git checkout -b feature/your-feature-name

python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install -r requirements.txt
python manage.py migrate

# Run tests
pytest

# Check code quality
flake8 .
black --check .
isort --check-only .

# Run security checks
bandit -r .
safety check

git add .
git commit -m "Add your descriptive commit message"
git push origin feature/your-feature-name

Open a Pull Request on GitHub with:

• Clear description of changes
• Reference to any related issues
• Screenshots if applicable

• Follow PEP 8 (enforced by flake8)
• Use Black for code formatting
• Sort imports with isort
• Write comprehensive tests for new features
• Add docstrings for complex functions
• Keep line length under 127 characters

This project uses GitHub Actions for continuous integration and deployment:

Every push and pull request triggers:

🧪 Testing Pipeline:

• Tests on Python 3.10, 3.11, and 3.12
• PostgreSQL and Redis service containers
• Full test suite execution with pytest
• Django system checks
• Code coverage reporting with Codecov

🔍 Code Quality Pipeline:

• Linting with flake8
• Code formatting check with black
• Import sorting check with isort

🛡️ Security Pipeline:

• Security vulnerability scanning with bandit
• Dependency vulnerability check with safety
• Semgrep static analysis

🤖 AI-Powered Review Pipeline:

• GitHub Copilot code review on PRs
• Automated code suggestions and improvements
• Django-specific best practices analysis
• Performance optimization recommendations
• Type checking with mypy

🐳 Docker Pipeline:

• Docker image build and test (on main branch)

The README includes badges showing:

• ✅ CI/CD pipeline status
• 🐍 Python version compatibility
• 🌐 Django version
• 📜 License information
• 📊 Code coverage percentage

• 🤖 GitHub Copilot: Automated code review for PRs
• 💡 AI Suggestions: Performance and best practices recommendations
• 🔍 Code Analysis: Static analysis with pylint, mypy, and vulture
• 🛡️ Security Scanning: Comprehensive security analysis

• main and develop branches require:
  • Passing CI checks
  • Code review approval
  • Up-to-date branches

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

• Issues: Report a Bug
• SecCodeSmith - contact@seccodesmith.pl

• Built with Django and Django REST Framework
• Testing powered by pytest
• Code quality ensured by Black, flake8, and isort
• Security scanning by Bandit and Safety
• CI/CD powered by GitHub Actions