README_.md

Task Management System (Microservices)

A Spring Cloud microservice ecosystem for managing tasks with a React front-end. An API Gateway exposes the platform through a single port, Eureka provides service discovery, and MongoDB persists user, task, and submission data. The solution can be run locally with Gradle/npm or containerised end-to-end with Docker Compose.

---

Overview

This project implements a Task Management system using a microservices architecture. The system consists of three main microservices plus infrastructure components:

• TaskUserService – authentication, JWT issuance, profile and admin endpoints.
• TaskService – task CRUD, assignment and completion workflows.
• TaskSubmissionService – submission lifecycle and coordination with other services via OpenFeign.
• EurekaServerConfiguration – service registry for discovery and health status.
• APIGateway – Spring Cloud Gateway with resilience policies and CORS/fallback handling.
• task-management-ui – React SPA consuming the gateway APIs.

Additional runtime services in Docker Compose:

• MongoDB (Docker)
• Zipkin (Docker) for tracing

---

Tech stack

• Java 17, Spring Boot 3.2, Spring Cloud 2023.0
• Gradle 8
• React 18 (Create React App)
• Node.js 18+, npm 9+
• MongoDB 6
• Docker & Docker Compose (Docker Engine 24+, Compose v2 recommended)
• Spring Security, Resilience4j, OpenFeign, Micrometer/Zipkin

Repository layout (high level)

APIGateWay/                 # Spring Cloud Gateway service
EurekaServerConfiguration/  # Eureka discovery server
TaskUserService/            # Authentication / User management service
TaskService/                # Task domain microservice
TaskSubmissionService/      # Submission microservice
task-management-ui/         # React single page application
build-all.sh                # Builds all services and UI
run-system.sh               # Builds and launches full stack with Compose
stop-system.sh              # Stops the Compose stack
docker-compose.yml         # Compose orchestration for services + MongoDB + Zipkin

---

Features (selected)

UserService

• POST /auth/signup — user registration
• POST /auth/signin — authentication (returns JWT)
• GET /api/user/profile — get user profile

TaskService

• POST /api/tasks/create — create new task (admin only)
• GET /api/tasks/{taskId} — get task details
• PUT /api/tasks/{taskId}/assign/{userId} — assign task to user (admin only)

TaskSubmissionService

• POST /api/submissions/submit — submit completed task (authenticated users)
• GET /api/submissions/{submissionId} — get submission details

---

Configuration

All Spring services accept environment overrides (via environment variables or application-*.properties) for values such as:

Variable	Applies to	Purpose	Default (local)
SERVER_PORT	All Spring services	HTTP port override	service-specific
SPRING_APP_NAME	All services	Service identifier / registration name	-
EUREKA_SERVER_URI	Gateway & microservices	Eureka discovery endpoint	http://localhost:8085/eureka
MONGODB_URI	Backends	MongoDB connection string	mongodb://localhost:27017/<db>
ZIPKIN_BASE_URL	All services	Zipkin tracing endpoint	http://localhost:9411
ZIPKIN_SAMPLER_PROBABILITY	All services	Tracing sampling rate	1.0

Each service also exposes domain-specific properties (JWT secrets, CORS allowed origins, etc.) in its application.properties/application-docker.properties files. Defaults are safe for local usage but must be overridden for production.

---

Prerequisites / System requirements

• JDK 17+
• Node.js 18+, npm 9+
• Docker Engine 24+ and Docker Compose v2 (or docker-compose v1)
• 8 GB RAM recommended when running full stack locally

---

Setup & Running

Option 1 — Full stack via Docker Compose (recommended for quick end-to-end runs)

1. (Optional) Create a Docker volume for MongoDB persistence:

   docker volume create mongo-data
   

2. Build and run everything (the run-system.sh helper can be used if present):

   ./run-system.sh
   # or
   docker compose up --build
   

3. Verify services are registered in Eureka (default port shown by the compose file):
   • Eureka dashboard: http://localhost:8085
   • API Gateway health: http://localhost:8090/actuator/health
   • Zipkin UI: http://localhost:9411
   • React dev UI: http://localhost:3000 (if using npm start instead of build)

Stop everything:

./stop-system.sh
# or
docker compose down

To remove persisted MongoDB data:

docker volume rm mongo-data

Option 2 — Run services locally (development)

1. Start MongoDB locally or via Docker:

   docker run -p 27017:27017 --name mongo -d mongo:6.0
   

2. Start Eureka server:

   cd EurekaServerConfiguration
   ./gradlew bootRun
   

3. Start services in separate terminals:

   cd TaskUserService && ./gradlew bootRun
   cd TaskService && ./gradlew bootRun
   cd TaskSubmissionService && ./gradlew bootRun
   cd APIGateWay && ./gradlew bootRun
   

4. Start React UI (dev mode):

   cd task-management-ui
   npm install
   npm start
   

When running behind the gateway, point the UI to the gateway base URL (example .env):

REACT_APP_API_BASE_URL=http://localhost:8090

---

Build

One-step build (bundles backends and UI)

./build-all.sh

Manual builds

• Backends: inside each service directory

./gradlew clean bootJar -x test

• UI

cd task-management-ui
npm install
npm run build

---

Troubleshooting

• MongoDB health check fails: ensure your host CPU supports AVX (required for MongoDB 6), or run a remote MongoDB instance and set MONGODB_URI accordingly.
• Port conflicts: adjust SERVER_PORT environment variable for services.
• Gateway CORS errors: set appropriate GATEWAY_ALLOWED_ORIGIN_* and TASK_ALLOWED_ORIGINS env vars to match your front-end origin(s).
• Zipkin unreachable: either run Zipkin container or comment out ZIPKIN_BASE_URL in configs to disable tracing.

---

Verification checklist

• Eureka dashboard shows USER-SERVICE, TASK-SERVICE, and TASK-SUBMISSION as UP.
• Gateway health endpoint returns {"status":"UP"}.
• Service actuator health endpoints are available (e.g. http://localhost:8081/actuator/health, :8082, :8083).
• MongoDB collections: users, tasks, submissions.

---

Notes

• Admin-only endpoints are protected by role checks (create/assign tasks).
• OpenFeign is used for inter-service HTTP clients.
• Production deployments should rotate secrets and secure all JWT keys / database credentials.

---

Contribution

Contributions are welcome — open an issue or submit a PR.

License

This project is licensed under the MIT License.

---

Happy shipping! 🚀