Team Project & Task Tracker

A collaborative web-based task tracker for teams, built with Java/Spring Boot, Python/FastAPI, and React.

📋 Features

• Real-time Collaboration: Multiple team members can work simultaneously
• Project Management: Create and manage multiple projects
• Task Tracking: JIRA-like task management with priorities and statuses
• Team Management: Assign tasks and manage team members
• Deployment Tracking: Monitor deployment status and progress
• Responsive UI: Works on desktop, tablet, and mobile devices

🏗️ Architecture

Backend Services

• Java Spring Boot API (Port 8080): Main REST API for project and task management
• Python FastAPI Service (Port 8000): Analytics, reporting, and data processing
• PostgreSQL Database: Centralized data store

Frontend

• React + Vite: Fast, modern UI with real-time updates
• Axios: HTTP client for API communication
• Tailwind CSS: Utility-first CSS framework

🚀 Quick Start

Prerequisites

• Docker & Docker Compose
• Node.js 20+ (for frontend development)
• JDK 17+ (for Java backend development)
• Python 3.11+ (for Python backend development)
• PostgreSQL 16+ (if running locally without Docker)

Option 1: Using Docker Compose (Recommended)

# Clone and navigate to project
cd Team-Project-Task-Tracker

# Start all services
docker-compose up -d

# Access the application
- Frontend: http://localhost:5173
- Java API: http://localhost:8080/api
- Python API: http://localhost:8000
- Database: localhost:5432

Option 2: Local Development

1. Start Database

docker run --name task_tracker_db \
  -e POSTGRES_USER=tasktracker \
  -e POSTGRES_PASSWORD=tasktracker_pass \
  -e POSTGRES_DB=task_tracker_db \
  -p 5432:5432 \
  postgres:16-alpine

2. Start Java Backend

cd backend-java
mvn clean install
mvn spring-boot:run

3. Start Python Backend

cd backend-python
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt
python -m uvicorn app.main:app --reload

4. Start React Frontend

cd frontend
npm install
npm run dev

📁 Project Structure

Team-Project-Task-Tracker/
├── backend-java/                 # Spring Boot REST API
│   ├── src/main/java/
│   │   └── com/tasktracker/
│   │       ├── api/              # REST Controllers
│   │       ├── model/            # JPA Entities
│   │       ├── repository/       # Data Access Layer
│   │       └── service/          # Business Logic
│   ├── pom.xml
│   └── Dockerfile
├── backend-python/               # FastAPI service
│   ├── app/
│   │   ├── api/                  # API routes
│   │   ├── models/               # SQLAlchemy models
│   │   └── services/             # Business logic
│   ├── requirements.txt
│   └── Dockerfile
├── frontend/                     # React application
│   ├── src/
│   │   ├── components/           # Reusable components
│   │   ├── pages/                # Page components
│   │   ├── hooks/                # Custom React hooks
│   │   └── App.jsx
│   ├── package.json
│   └── Dockerfile
├── database/                     # Database migrations
│   └── V1__Initial_Schema.sql
├── deployment/                   # Kubernetes configs
│   ├── kubernetes-java.yaml
│   └── kubernetes-python.yaml
├── docs/                         # Documentation
└── docker-compose.yml            # Docker Compose config

🔄 Database Schema

Tables

• users: Team members
• teams: Team groupings
• user_teams: Many-to-many relationship between users and teams
• projects: Projects managed by teams
• tasks: Individual tasks with JIRA-like tracking

Task Statuses

• TODO
• IN_PROGRESS
• IN_REVIEW
• DONE
• BLOCKED

Task Priorities

• LOW
• MEDIUM
• HIGH
• CRITICAL

🔐 API Endpoints

Tasks

• GET /api/v1/tasks - Get all tasks
• GET /api/v1/tasks/{id} - Get task by ID
• POST /api/v1/tasks - Create new task
• PUT /api/v1/tasks/{id} - Update task
• DELETE /api/v1/tasks/{id} - Delete task
• GET /api/v1/tasks/project/{projectId} - Get tasks by project

🧪 Testing

Java Backend

cd backend-java
mvn test

Python Backend

cd backend-python
pytest

Frontend

cd frontend
npm test

📦 Deployment

Docker Compose

docker-compose up -d

Kubernetes

# Deploy Java backend
kubectl apply -f deployment/kubernetes-java.yaml

# Deploy Python backend
kubectl apply -f deployment/kubernetes-python.yaml

🔄 CI/CD Pipeline

The project includes GitHub Actions workflow for:

• Building and testing all services
• Running linters and formatters
• Docker image building
• Deployment to production

See .github/workflows/ci-cd.yml for details.

👥 Team Collaboration

• All team members can view real-time task updates
• Assign tasks to team members
• Track deployment progress
• Monitor project status
• View team member availability

📝 Environment Configuration

Backend Java (.env)

DB_HOST=localhost
DB_PORT=5432
DB_NAME=task_tracker_db
DB_USER=tasktracker
DB_PASSWORD=tasktracker_pass

Backend Python (.env)

DATABASE_URL=postgresql://tasktracker:tasktracker_pass@localhost:5432/task_tracker_db

Frontend (.env)

VITE_API_URL=http://localhost:8080/api
VITE_PYTHON_API_URL=http://localhost:8000

🛠️ Development Setup

1. Install dependencies across all services
2. Configure environment variables
3. Start the database
4. Run migrations
5. Start all backend services
6. Start the frontend

📚 Additional Resources

• Spring Boot Documentation
• FastAPI Documentation
• React Documentation
• PostgreSQL Documentation

🤝 Contributing

1. Create a feature branch
2. Make your changes
3. Run tests
4. Submit a pull request

📄 License

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

📧 Support

For support and questions, please reach out to the team.