LJ POLYTECHNIC

A MINI PROJECT REPORT

ON

To-Do list
(2025 - 2026)

JAVA PROGRAMMING

Submitted by:
Sr. Enrollment Student Name
1 23012250910003 Adrodiya Ashok
2 23012250910017 Desai Tirth
3 23012250910019 Dharukiya Aditya
4 23012250910026 Goyani Meet
5 23012250910059 Moghariya Arpit
 PROJECT DESCRIPTION
Introduction

The To-Do List Application is a web-based system developed to simplify the process
of managing daily tasks and responsibilities. In today’s fast-paced environment,
individuals often struggle to keep track of their activities, deadlines, and priorities,
which can lead to missed opportunities or decreased productivity. This application
addresses that challenge by providing a digital platform where tasks can be created,
organized, monitored, and completed in an efficient manner.

The project is designed using a full-stack approach, combining the robustness of a

Java Spring Boot backend with the flexibility of a modern HTML, CSS, and
JavaScript frontend. This ensures a smooth interaction between the server and the
user interface, enabling features such as task creation, editing, deletion, reminders, and
real-time updates without page reloads. The application also offers a clean and
responsive design, ensuring accessibility across different devices and screen sizes.

Beyond serving as a personal productivity tool, this project demonstrates the

integration of backend and frontend technologies in a cohesive system. It highlights
how software engineering principles such as modularity, scalability, and
maintainability can be applied in practice. As a result, the application not only
provides value to end users but also acts as a practical example of modern web
development practices using Java and related technologies.

Objectives of the Project

The objectives of the project are as follows:

1. To provide users with a structured and reliable platform for managing daily tasks
effectively.

2. To enable task organization with additional details such as priority levels and
reminder settings. To design a user-friendly and interactive frontend using
HTML, CSS, and JavaScript.

1
 3. To improve productivity by offering features like search, filters, and statistics that
help users track progress.

4. To ensure timely completion of tasks through reminder notifications and alerts.

5. To support efficient task handling by allowing users to add, edit, delete, and
complete tasks easily.

6. To enhance usability with bulk actions that allow managing multiple tasks
simultaneously.

7. To build a scalable and extensible system that can be integrated with databases,
authentication modules, and cloud services in the future.

Technology Stack

 Frontend:
The frontend is built using HTML5, CSS3, and JavaScript, providing a clean,
responsive, and interactive interface.
 HTML is used to structure the content of the application.
 CSS handles the design, layouts, and styling to create a user-friendly
experience.
 JavaScript adds interactivity by enabling dynamic features like adding,
editing, deleting tasks, setting reminders, searching, filtering, and updating
task status without reloading the page.

 Backend:
The backend is powered by Java 17 and Spring Boot 3.1.4, which provides a robust
and scalable framework for building RESTful services.

 Spring Boot manages application configuration and runs the application with
an embedded Tomcat server.

 Spring Web handles HTTP requests and exposes REST APIs for task
management operations such as Create, Read, Update, and Delete (CRUD).
 Maven is used as the build and dependency management tool, ensuring
smooth integration of required libraries and plugins.

2
Features of the Project
The major features of this project include:
1. Task Creation: Users can create new tasks by entering a title, description, priority,
and optional reminder date and time. This allows tasks to be stored in an organized
manner.
2. Edit and Update Tasks: Existing tasks can be modified at any time, ensuring
flexibility when priorities or deadlines change.
3. Delete Tasks: Unwanted tasks can be removed permanently from the list, keeping the
task manager clean and relevant.
4. Mark as Completed: Tasks can be marked as completed, making it easier for users to
track progress and distinguish between pending and finished work.
5. Search Functionality: A built-in search feature allows users to quickly find tasks by
typing keywords, improving accessibility for large task lists.
6. Responsive User Interface: The frontend is designed to be simple, clean, and
responsive, ensuring it works smoothly across different devices and screen sizes.

Benefits of the Project

The project offers several benefits, both educational and practical:

 Improved Task Organization: The application provides a structured way to manage

daily activities, helping users keep track of tasks, priorities, and deadlines in one
place.
 Enhanced Productivity: By offering reminders, filters, and statistics, the system
helps users focus on important tasks and complete them on time, leading to better
time management.

 User-Friendly Interface: The clean and responsive design makes it easy for anyone
to add, edit, delete, or manage tasks without requiring technical knowledge.
 Time-Saving Features: With bulk actions, search functionality, and filters, users can
quickly manage large numbers of tasks efficiently.
 Scalability and Extensibility: Since the backend is built with Spring Boot and REST
APIs, the project can be easily extended with new features like database support, user
authentication, or cloud deployment

3
Code:
[Link]
package [Link];

import [Link];
import [Link];
import [Link].*;

import [Link];
import [Link];
import [Link];
import [Link].*;
import [Link];

@RestController
@RequestMapping("/api/tasks")
public class ApiController {
private final AtomicLong idGen = new AtomicLong([Link]());
private final DateTimeFormatter formatter = [Link]("yyyy-MM-dd
HH:mm:ss");

@SuppressWarnings("unchecked")
private List<Task> getTaskList(HttpSession session) {
var attr = [Link]("tasks");
if (attr == null) {
List<Task> list = new ArrayList<>();
[Link]("tasks", list);
return list;
}
return (List<Task>) attr;
}

@GetMapping

4
 public List<Task> all(HttpSession session) {
return getTaskList(session);
}

@PostMapping
public Task create(@RequestBody Map<String, Object> body, HttpSession session) {
List<Task> tasks = getTaskList(session);
long id = [Link]();
String text = (String) [Link]("text", "");
String priority = (String) [Link]("priority", "low");
String reminderStr = (String) [Link]("reminder", null);
LocalDateTime reminder = null;
if (reminderStr != null && ![Link]()) {
try {
reminder = [Link](reminderStr);
} catch (Exception ex) {
// ignore parse errors
}
}
String createdAt = [Link]().format(formatter);
Task task = new Task(id, text, priority, reminder, createdAt);
[Link](0, task);
[Link]("tasks", tasks);
return task;
}

@PutMapping("/{id}")
public ResponseEntity<Task> update(@PathVariable long id, @RequestBody Map<String,
Object> body, HttpSession session) {
List<Task> tasks = getTaskList(session);
Optional<Task> opt = [Link]().filter(t -> [Link]() == id).findFirst();
if ([Link]()) return [Link]().build();
Task task = [Link]();
if ([Link]("text")) [Link]((String) [Link]("text"));

5
 if ([Link]("priority")) [Link]((String) [Link]("priority"));
if ([Link]("reminder")) {
String r = (String) [Link]("reminder");
if (r == null || [Link]()) [Link](null);
else {
try { [Link]([Link](r)); } catch (Exception e) { }
}
}
if([Link]("completed"))
[Link]([Link]([Link]("completed").toString()));
[Link]("tasks", tasks);
return [Link](task);
}

@DeleteMapping("/{id}")
public ResponseEntity<Void> delete(@PathVariable long id, HttpSession session) {
List<Task> tasks = getTaskList(session);
boolean removed = [Link](t -> [Link]() == id);
[Link]("tasks", tasks);
if (removed) return [Link]().build();
return [Link]().build();
}

@PostMapping("/bulk")
public ResponseEntity<List<Task>> bulk(@RequestBody Map<String, Object> body,
HttpSession session) {
String action = (String) [Link]("action", "");
List<Task> tasks = getTaskList(session);
switch (action) {
case "selectAll":
for (Task t: tasks) [Link](true);
break;
case "deselectAll":
for (Task t: tasks) [Link](false);

6
 break;
case "completeSelected":
for (Task t: tasks) if ([Link]()) { [Link](true); [Link](false); }
break;
case "deleteSelected":
[Link](Task::isSelected);
break;
case "clearCompleted":
[Link](Task::isCompleted);
break;
}
[Link]("tasks", tasks);
return [Link](tasks);
}
}

[Link]
package [Link];

import [Link];
import [Link];

@Controller
public class PageController {
@GetMapping("/")
public String index() {
return "index"; // Thymeleaf template (templates/[Link])
}
}

7
[Link]
package [Link];
import [Link];
public class Task {
private long id;
private String text;
private boolean completed;
private String priority; // low|medium|high
private LocalDateTime reminder; // nullable
private String createdAt; // friendly string for frontend
private boolean selected;
private boolean reminderShown;

public Task() {}

public Task(long id, String text, String priority, LocalDateTime reminder, String createdAt)
{
[Link] = id;
[Link] = text;
[Link] = false;
[Link] = priority;
[Link] = reminder;
[Link] = createdAt;
[Link] = false;
[Link] = false;
}

public long getId() { return id; }

public void setId(long id) { [Link] = id; }

public String getText() { return text; }

public void setText(String text) { [Link] = text; }

8
 public boolean isCompleted() { return completed; }
public void setCompleted(boolean completed) { [Link] = completed; }

public String getPriority() { return priority; }

public void setPriority(String priority) { [Link] = priority; }

public LocalDateTime getReminder() { return reminder; }

public void setReminder(LocalDateTime reminder) { [Link] = reminder; }

public String getCreatedAt() { return createdAt; }

public void setCreatedAt(String createdAt) { [Link] = createdAt; }

public boolean isSelected() { return selected; }

public void setSelected(boolean selected) { [Link] = selected; }

public boolean isReminderShown() { return reminderShown; }

public void setReminderShown(boolean reminderShown) { [Link] =
reminderShown; }
}

[Link]
package [Link];

import [Link];
import [Link];

@SpringBootApplication
public class TodoApplication {
public static void main(String[] args) {
[Link]([Link], args);
}
}

9
[Link]
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Complete To-Do List</title>
<link rel="stylesheet" href="/css/[Link]">
</head>
<body>
<div class="container">
<div class="header">
<h1> To-Do List</h1>
<div class="stats">
<div class="stat-item">
<span class="stat-number" id="totalTasks">0</span>
<span>Total Tasks</span>
</div>
<div class="stat-item">
<span class="stat-number" id="completedTasks">0</span>
<span>Completed</span>
</div>
<div class="stat-item">
<span class="stat-number" id="pendingTasks">0</span>
<span>Pending</span>
</div>
</div>
</div>

<div class="input-section">
<div class="input-container">
<input type="text" class="task-input" id="taskInput" placeholder="What needs to be
done?" maxlength="200">

10
 <select class="priority-select" id="prioritySelect">
<option value="low">Low Priority</option>
<option value="medium">Medium Priority</option>
<option value="high">High Priority</option>
</select>
<input type="datetime-local" class="reminder-input" id="reminderInput" title="Set
reminder">
<button class="add-btn" id="addBtn">Add Task</button>
</div>

<div class="search-container">
<input type="text" class="search-input" id="searchInput" placeholder="🔍 Search
tasks...">
</div>

<div class="filters">
<button class="filter-btn active" data-filter="all">All Tasks</button>
<button class="filter-btn" data-filter="pending">Pending</button>
<button class="filter-btn" data-filter="completed">Completed</button>
<button class="filter-btn" data-filter="high">High Priority</button>
<button class="filter-btn" data-filter="medium">Medium Priority</button>
<button class="filter-btn" data-filter="low">Low Priority</button>
</div>

<div class="bulk-actions">
<button class="bulk-btn" id="selectAllBtn">Select All</button>
<button class="bulk-btn" id="deselectAllBtn">Deselect All</button>
<button class="bulk-btn" id="completeSelectedBtn">Complete Selected</button>
<button class="bulk-btn" id="deleteSelectedBtn">Delete Selected</button>
<button class="bulk-btn" id="clearCompletedBtn">Clear Completed</button>
</div>
</div>

11
 <div class="tasks-section">
<div id="tasksList"></div>
<div class="empty-state" id="emptyState">
<svg viewBox="0 0 24 24" fill="currentColor">
<path d="M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-
.9-2-2-2zm-5 14H7v-2h7v2zm3-4H7v-2h10v2zm0-4H7V7h10v2z"/>
</svg>
<h3>No tasks yet!</h3>
<p>Add your first task above to get started.</p>
</div>
</div>
</div>

<script src="/js/[Link]"></script>
</body>
</html>

[Link]
<project xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
[Link]
<modelVersion>4.0.0</modelVersion>
<groupId>[Link]</groupId>
<artifactId>complete-todo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>complete-todo</name>
<description>Server-backed ToDo App (Spring Boot + REST)</description>
<parent>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-parent</artifactId>

12
 <version>3.1.4</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<[Link]>17</[Link]>
</properties>
<dependencies>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>[Link]</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

13
Output:

[Figure 1: Main Page]

[Figure 1: Task added ]

14
[Figure 3: Task Reminder]

[Figure 4: Completed Task]

15
 CONCLUSION
The To-Do List Application successfully demonstrates how modern web
technologies can be combined to build a practical and user-friendly productivity
tool. By integrating a Spring Boot backend with a dynamic HTML, CSS, and
JavaScript frontend, the project offers essential features such as task creation,
editing, deletion, reminders, filters, bulk actions, and task statistics. These
functionalities not only help users organize their daily activities but also improve
time management and overall [Link], this project achieves its
objectives of providing a simple yet powerful task management solution while
also serving as a valuable learning resource for full-stack development. It
demonstrates how software engineering principles can be applied in real-world
applications to create systems that are both functional and adaptable for future
growth.

16