A robust, feature-rich backend application designed for personalized task management, integrating advanced filtering, dynamic notifications (Kafka/SMTP), time tracking, and experimental AI-powered natural language querying.

Status	Details
Language
Framework
Database
Messaging
Security
Documentation

TaskPilot is a high-performance backend system built on Spring Boot 3.x, focused on providing secure, scalable, and auditable task management capabilities. The core problem solved is managing complex user workflows—tasks with sub-checklists, detailed time estimation, and mandatory time tracking—all while ensuring data isolation and providing versatile communication channels.

The project features decoupled asynchronous/synchronous notification mechanisms and implements advanced querying using the JPA Specification pattern. A notable feature is the secure integration with Google Gemini, allowing users to query their private task data using natural language, safeguarded by row-level security enforcement.

The following features are derived directly from the application's controllers and services:

• User Authentication & Security: Implements JWT token generation, validation, and authorization using Spring Security, securing all task endpoints. Passwords are secured using BCryptPasswordEncoder.
• Comprehensive Task Management: Supports CRUD operations for tasks, tracking task attributes such as TaskPriority and TaskStatus (e.g., NOT_STARTED, INPROGRESS, COMPLETED).
• Dynamic Task Filtering (JPA Specification): Offers a single unified endpoint for complex querying, supporting combination filters across multiple fields including task name, status, priority, category details, keyword searching, and creation date ranges.
• Time Tracking and Auditing:
  • Uses JPA Auditing (Basemodel) to automatically populate createdAt and updatedAt timestamps.
  • Allows users to log task start/completion times (startDateTime, endDateTime).
  • Calculates totalTimeTaken and provides a comparison remark against the expectedTaskTime.
• Checklist Management: Supports creating, retrieving, deleting, starting, and completing associated ChecklistItem subtasks for any main task.
  • Constraint Enforcement: Logic prevents users from marking a main task complete if associated checklist items are still pending.
  • Time Validation: Enforces that the total estimated time of all checklist items does not exceed the estimated time of the parent task (ChecklistTimeExceedsException).
• Configurable Notification System: Uses a Strategy Pattern via UnifiedNotificationDispatcher. The system can be toggled by the use.kafka property to operate in two modes:
  1. Asynchronous (Kafka): Dispatches email requests to a Kafka topic for processing by an EmailKafkaConsumer.
  2. Synchronous (Direct): Immediately sends emails using either the configured SendGrid API or SMTP server (switchable via email.provider).
• Scheduled Reminders: A daily scheduler (ReminderScheduler) fetches all users and their pending tasks (TaskStatus.COMPLETED excluded) and dispatches daily reminder emails via the unified notification system.
• AI Data Integration (Secure NL-to-SQL): The ChatbotIntegrationController allows users to submit natural language prompts which are converted to runnable SQL queries via the Gemini API. The integration ensures data security by forcing the AI to include WHERE user_id = %d in all generated queries, limiting data access to the authenticated user.

TaskPilot employs a layered service architecture utilizing Spring framework components heavily for decoupling and advanced functionality.

1. Auditing and Soft Deletes: All entities (User, Task, Category, etc.) inherit from Basemodel, which utilizes @EntityListeners(AuditingEntityListener.class) to automate the tracking of createdAt and updatedAt, and includes a isDeleted flag for optional soft deletion.
2. Pluggable Notifications (Strategy Pattern): The UnifiedNotificationDispatcher acts as a facade, deciding whether to use the Kafka producer (NotificationDispatcher) or direct email sender (DirectNotificationDispatcher) based on the runtime property use.kafka. This allows the application to switch seamlessly between asynchronous and synchronous communication based on deployment needs.
3. Secure AI Layer: The GeminiIntegrationService uses a pre-cached schema (SchemaCache) to structure its prompts, guaranteeing that the AI generates valid, production-ready SQL. Security is hardcoded by injecting the authenticated user's ID (userId) into the LLM prompt to ensure all generated queries contain a mandatory WHERE user_id = %d clause.

To run this application, you must have the following installed:

• Java Development Kit (JDK): Version 17 or higher.
• Maven: For dependency management and building (pom.xml present).
• MySQL Database: The application is configured to connect to an external MySQL instance.
• Kafka (Optional): If use.kafka=true, a local Kafka broker must be running on localhost:9092.

git clone <repository_url>
cd TaskPilot_TaskManager

You must set the following critical environment variables or replace the placeholders in application.properties (or your preferred environment manager):

Configuration Toggle (application.properties):

The application default configuration uses direct email dispatch (SMTP). If you wish to use Kafka, update these properties:

# To enable Kafka queue dispatch, mark it as true:
use.kafka=true
# choose email provider irrespective of use.kafka value, choose out of sendgrid and smtp (note: both require additional setup of access keys such as sendgrid api key or gmail app password):
email.provider=smtp
# Spring Kafka bootstrap servers configured below (default: localhost:9092)

1. Build the Project:

   mvn clean install

2. Run the Application:

   mvn spring-boot:run

The application will start on the default Spring Boot port (typically 8080).

All endpoints, except those under /auth, require a JWT Bearer token.

Once authenticated, include the JWT in the Authorization: Bearer <token> header for all subsequent API calls.

The following core functional routes are available: