TaskService/README.md

Task Service

Overview

The Task Service is a microservice component of the Task Management System that handles all task-related operations. It provides a RESTful API for creating, reading, updating, deleting, and managing tasks within the system.

Purpose

This service is responsible for:

• Task CRUD Operations: Create, retrieve, update, and delete tasks
• Task Assignment: Assign tasks to specific users
• Task Status Management: Track task progression (PENDING → ASSIGNED → DONE)
• Task Filtering & Sorting: Filter tasks by status and sort by deadline or creation date
• User Integration: Communicates with User Service for authentication and authorization
• Admin Controls: Only administrators can create tasks

Architecture

Technology Stack

• Framework: Spring Boot 3.2.2
• Language: Java 17
• Database: MongoDB
• Service Discovery: Netflix Eureka Client
• Inter-Service Communication: OpenFeign
• Distributed Tracing: Zipkin with Micrometer
• Build Tool: Gradle

Key Components

1. Controllers

   • TaskController: Handles all task-related REST endpoints
   • HomeController: Provides health check and welcome endpoints

2. Services

   • TaskService: Interface defining task operations
   • TaskServiceImplementation: Business logic implementation
   • UserService: Feign client for User Service integration

3. Repository

   • TaskRepository: MongoDB repository for task persistence

4. Models

   • Task: Main task entity
   • UserDTO: User data transfer object
   • TaskStatus: Enum for task states (PENDING, ASSIGNED, DONE)

5. Exception Handling

   • GlobalExceptionHandler: Centralized exception handling
   • TaskNotFoundException: Custom exception for task not found scenarios

Database Schema

Task Collection

{
  "_id": "string",
  "title": "string",
  "description": "string",
  "imageUrl": "string",
  "assignedUserId": "string",
  "status": "PENDING | ASSIGNED | DONE",
  "deadline": "LocalDateTime",
  "createAt": "LocalDateTime",
  "tags": ["string"]
}

API Endpoints

Base URL

http://localhost:8082/api/tasks

Endpoints

1. Create Task (Admin Only)

POST /api/tasks
Headers:
  Authorization: Bearer <JWT_TOKEN>
Body:
{
  "title": "Task Title",
  "description": "Task Description",
  "imageUrl": "https://example.com/image.png",
  "deadline": "2024-12-31T23:59:59",
  "tags": ["tag1", "tag2"]
}
Response: 201 CREATED

2. Get Task by ID

GET /api/tasks/{id}
Headers:
  Authorization: Bearer <JWT_TOKEN>
Response: 200 OK

3. Get All Tasks

GET /api/tasks?status=PENDING&sortByDeadline=asc&sortByCreatedAt=desc
Headers:
  Authorization: Bearer <JWT_TOKEN>
Query Parameters:
  - status: PENDING | ASSIGNED | DONE (optional)
  - sortByDeadline: asc | desc (optional)
  - sortByCreatedAt: asc | desc (optional)
Response: 200 OK

4. Get Assigned User Tasks

GET /api/tasks/user?status=ASSIGNED&sortByDeadline=asc
Headers:
  Authorization: Bearer <JWT_TOKEN>
Query Parameters:
  - status: PENDING | ASSIGNED | DONE (optional)
  - sortByDeadline: asc | desc (optional)
  - sortByCreatedAt: asc | desc (optional)
Response: 200 OK

5. Assign Task to User

PUT /api/tasks/{taskId}/user/{userId}/assigned
Headers:
  Authorization: Bearer <JWT_TOKEN>
Response: 200 OK

6. Update Task

PUT /api/tasks/{id}
Headers:
  Authorization: Bearer <JWT_TOKEN>
Body:
{
  "title": "Updated Title",
  "description": "Updated Description",
  "status": "ASSIGNED",
  "deadline": "2024-12-31T23:59:59"
}
Response: 200 OK

7. Delete Task

DELETE /api/tasks/{id}
Response: 204 NO CONTENT

8. Complete Task

PUT /api/tasks/{id}/complete
Response: 200 OK

9. Health Check

GET /tasks
Response: 200 OK - "Welcome to Task Service"

Configuration

application.properties

# Server Configuration
server.port=8082

# MongoDB Configuration
spring.data.mongodb.uri=mongodb://localhost:27017/tasks

# Application Name
spring.application.name=TASK-SERVICE

# Eureka Client Configuration
eureka.instance.prefer-ip-address=true
eureka.client.fetch-registry=true
eureka.client.register-with-eureka=true
eureka.client.service-url.defaultZone=http://localhost:8085/eureka

# Zipkin Tracing Configuration
spring.zipkin.base-url=http://localhost:9411
spring.sleuth.sampler.probability=1.0

Prerequisites

Before running the Task Service, ensure you have:

1. Java 17 or higher installed
2. MongoDB installed and running on localhost:27017
3. Eureka Server running on http://localhost:8085
4. User Service running on http://localhost:8081 (for Feign client)
5. Zipkin Server (optional) running on http://localhost:9411 for distributed tracing

How to Run

Method 1: Using Gradle Wrapper

1. Navigate to TaskService directory

cd TaskService

2. Build the application

./gradlew clean build

3. Run the application

./gradlew bootRun

Method 2: Using JAR file

1. Build the JAR

./gradlew clean build

2. Run the JAR

java -jar build/libs/TaskService-0.0.1-SNAPSHOT.jar

Method 3: Using Docker

1. Build the Docker image

docker build -t task-service:latest .

2. Run the Docker container

docker run -p 8082:8082 \
  -e SPRING_DATA_MONGODB_URI=mongodb://host.docker.internal:27017/tasks \
  -e EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE=http://host.docker.internal:8085/eureka \
  task-service:latest

Method 4: Using Docker Compose (Recommended)

From the root directory of the project:

docker-compose up task-service

Verification

Once the service is running, verify it's working:

1. Check Service Health

curl http://localhost:8082/tasks

Expected response: "Welcome to Task Service"

2. Check Eureka Registration

Visit http://localhost:8085 and verify that TASK-SERVICE is registered.

3. Check MongoDB Connection

Ensure the MongoDB database tasks is created and accessible.

Integration with Other Services

User Service Integration

The Task Service communicates with the User Service using OpenFeign:

• URL: http://localhost:8081
• Endpoint: /api/users/profile
• Purpose: Fetch user profile information for authentication and authorization

Eureka Service Discovery

The Task Service registers itself with Eureka Server for service discovery:

• Service Name: TASK-SERVICE
• Eureka Server: http://localhost:8085/eureka

Zipkin Tracing

Distributed tracing is enabled for monitoring:

• Zipkin URL: http://localhost:9411
• Sampling Probability: 100% (all requests are traced)

Authentication & Authorization

All endpoints (except the health check) require JWT authentication:

• Header: Authorization: Bearer <JWT_TOKEN>
• Admin Role: Required for creating tasks (ROLE_ADMIN)
• User Verification: JWT is validated via User Service

Error Handling

The service includes comprehensive error handling:

Common Error Responses

400 Bad Request

{
  "timestamp": "2024-11-10T10:30:00",
  "message": "Invalid request parameters",
  "status": 400,
  "error": "Bad Request"
}

401 Unauthorized

{
  "timestamp": "2024-11-10T10:30:00",
  "message": "JWT required...",
  "status": 401,
  "error": "Unauthorized"
}

404 Not Found

{
  "timestamp": "2024-11-10T10:30:00",
  "message": "Task not found with id: 12345",
  "status": 404,
  "error": "Task Not Found"
}

500 Internal Server Error

{
  "timestamp": "2024-11-10T10:30:00",
  "message": "Internal server error",
  "status": 500,
  "error": "Internal Server Error"
}

Task Lifecycle

1. PENDING: Task is created (by admin only)
2. ASSIGNED: Task is assigned to a user
3. DONE: Task is marked as completed

Development

Project Structure

TaskService/
├── src/
│   ├── main/
│   │   ├── java/in/garvit/tasks/
│   │   │   ├── TaskServiceApplication.java
│   │   │   ├── controller/
│   │   │   │   ├── HomeController.java
│   │   │   │   └── TaskController.java
│   │   │   ├── service/
│   │   │   │   ├── TaskService.java
│   │   │   │   ├── TaskServiceImplementation.java
│   │   │   │   └── UserService.java
│   │   │   ├── repository/
│   │   │   │   └── TaskRepository.java
│   │   │   ├── taskModel/
│   │   │   │   ├── Task.java
│   │   │   │   └── UserDTO.java
│   │   │   ├── enums/
│   │   │   │   └── TaskStatus.java
│   │   │   └── exception/
│   │   │       ├── GlobalExceptionHandler.java
│   │   │       └── TaskNotFoundException.java
│   │   └── resources/
│   │       └── application.properties
│   └── test/
│       └── java/in/garvit/tasks/
│           └── TaskServiceApplicationTests.java
├── build.gradle
├── Dockerfile
└── README.md

Building from Source

# Clone the repository
git clone <repository-url>

# Navigate to TaskService
cd TaskService

# Build the project
./gradlew clean build

# Run tests
./gradlew test

# Run the application
./gradlew bootRun

Testing

Run Unit Tests

./gradlew test

Test Coverage

./gradlew test jacocoTestReport

Troubleshooting

Common Issues

1. MongoDB Connection Failed

Error: Connection refused to MongoDB Solution: Ensure MongoDB is running:

# Start MongoDB
sudo systemctl start mongod

# Check status
sudo systemctl status mongod

2. Eureka Registration Failed

Error: Cannot register with Eureka Solution: Ensure Eureka Server is running on port 8085

3. User Service Communication Failed

Error: Feign client error Solution: Ensure User Service is running on port 8081

4. Port Already in Use

Error: Port 8082 is already in use Solution: Change the port in application.properties or kill the process:

# Find process using port 8082
lsof -i :8082

# Kill the process
kill -9 <PID>

Performance Considerations

• Database Indexing: Consider adding indexes on frequently queried fields (e.g., assignedUserId, status)
• Caching: Implement caching for frequently accessed tasks
• Pagination: Add pagination for large result sets
• Connection Pooling: MongoDB connection pool is managed by Spring Data

Security Considerations

• All endpoints require JWT authentication
• Only admins can create tasks
• User validation is performed via User Service
• Sensitive data should be encrypted at rest
• HTTPS should be used in production

Monitoring

Health Check Endpoint

curl http://localhost:8082/actuator/health

Metrics Endpoint

curl http://localhost:8082/actuator/metrics

Zipkin Dashboard

Access Zipkin UI at: http://localhost:9411

Future Enhancements

• Add pagination support for task listings
• Implement task comments/notes feature
• Add task priority levels
• Implement recurring tasks
• Add file attachments to tasks
• Implement task notifications
• Add task templates
• Implement task categories
• Add advanced search capabilities

Contributing

1. Fork the repository
2. Create a feature branch
3. Commit your changes
4. Push to the branch
5. Create a Pull Request

License

This project is part of the Task Management System microservices architecture.

Contact

Author: Garvit Pathak (garvitpathak27) Email: [Your Email] GitHub: [Your GitHub Profile]

---

Note: This service is part of a larger microservices ecosystem. Ensure all dependent services are running for full functionality.