add a GlobalExceptionHandler and TaskNotFoundException

Author: ColtonRandall

src/main/java/com/taskmanagerapi/controller/TaskController.java

@@ -20,15 +20,10 @@ public TaskController(TaskService taskService) {
 
     @PostMapping("/tasks")
     public ResponseEntity<Task> addTask(@RequestBody Map<String, String> request) {
-        try {
-            String name = request.get("name");
-            String description = request.get("description");
+        String name = request.get("name");
+        String description = request.get("description");
 
-            Task task = taskService.addTask(name, description);
-            return ResponseEntity.ok(task);
-        } catch (IllegalArgumentException e) {
-            return ResponseEntity.badRequest().build();
-        }
+        return ResponseEntity.ok(taskService.addTask(name, description));
     }
 
     @GetMapping("/tasks")
@@ -38,42 +33,31 @@ public ResponseEntity<List<Task>> getAllTasks() {
 
     @GetMapping("/tasks/{id}")
     public ResponseEntity<Task> getTask(@PathVariable String id) {
-        return taskService.getTask(id)
-                .map(ResponseEntity::ok)
-                .orElse(ResponseEntity.notFound().build());
+        return ResponseEntity.ok(taskService.getTask(id));
     }
 
     @GetMapping("/tasks/search/{name}")
     public ResponseEntity<Task> searchTaskByName(@PathVariable String name) {
-        return taskService.searchTaskByName(name)
-                .map(ResponseEntity::ok)
-                .orElse(ResponseEntity.notFound().build());
+        return ResponseEntity.ok(taskService.searchTaskByName(name));
     }
 
     @GetMapping("/tasks/search/status/{status}")
     public ResponseEntity<List<Task>> searchTaskByStatus(@PathVariable TaskStatus status) {
-        List<Task> tasks = taskService.searchTaskByStatus(status);
-        return ResponseEntity.ok(tasks);
+        return ResponseEntity.ok(taskService.searchTaskByStatus(status));
     }
 
     @PatchMapping("/tasks/{id}/complete")
     public ResponseEntity<Task> completeTask(@PathVariable String id) {
-        return taskService.completeTask(id)
-                .map(ResponseEntity::ok)
-                .orElse(ResponseEntity.notFound().build());
+        return ResponseEntity.ok(taskService.completeTask(id));
     }
 
     @DeleteMapping("/tasks/{id}")
     public ResponseEntity<Task> deleteTask(@PathVariable String id) {
-        return taskService.deleteTask(id)
-                .map(ResponseEntity::ok)
-                .orElse(ResponseEntity.notFound().build());
+        return ResponseEntity.ok(taskService.deleteTask(id));
     }
 
     @PatchMapping("/tasks/{id}")
     public ResponseEntity<Task> undoDelete(@PathVariable String id) {
-        return taskService.undoDelete(id)
-                .map(ResponseEntity::ok)
-                .orElse(ResponseEntity.notFound().build());
+        return ResponseEntity.ok(taskService.undoDelete(id));
     }
 }

src/main/java/com/taskmanagerapi/exception/GlobalExceptionHandler.java

@@ -0,0 +1,23 @@
+package com.taskmanagerapi.exception;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+
+import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
+import java.util.Map;
+
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(TaskNotFoundException.class)
+    public ResponseEntity<Map<String, Object>> handleTaskNotFound(TaskNotFoundException ex) {
+        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of(
+                "error", ex.getMessage(),
+                "status", 404,
+                "timestamp", LocalDateTime.now().truncatedTo(ChronoUnit.SECONDS)
+        ));
+    }
+}

src/main/java/com/taskmanagerapi/exception/TaskNotFoundException.java

@@ -0,0 +1,8 @@
+package com.taskmanagerapi.exception;
+
+public class TaskNotFoundException extends RuntimeException {
+
+    public TaskNotFoundException(String id) {
+        super("Task not found: " + id);
+    }
+}

src/main/java/com/taskmanagerapi/service/TaskService.java

@@ -1,21 +1,18 @@
 package com.taskmanagerapi.service;
 
+import com.taskmanagerapi.exception.TaskNotFoundException;
 import com.taskmanagerapi.model.Task;
 import com.taskmanagerapi.model.TaskStatus;
 import com.taskmanagerapi.repository.TaskRepository;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
-import java.util.Optional;
 
 import static com.taskmanagerapi.model.TaskStatus.*;
 
 @Service
 public class TaskService {
-    private static final Logger logger = LoggerFactory.getLogger(TaskService.class);
 
     private final TaskRepository taskRepository;
 
@@ -32,49 +29,42 @@ public List<Task> getAllTasks() {
         return taskRepository.findAll();
     }
 
-    public Optional<Task> getTask(String id) {
-        return taskRepository.findById(id);
+    public Task getTask(String id) {
+        return taskRepository.findById(id)
+                .orElseThrow(() -> new TaskNotFoundException(id));
     }
 
-    public Optional<Task> searchTaskByName(String name) {
-        return taskRepository.findTaskByName(name);
+    public Task searchTaskByName(String name) {
+        return taskRepository.findTaskByName(name)
+                .orElseThrow(() -> new TaskNotFoundException(name));
     }
 
     public List<Task> searchTaskByStatus(TaskStatus status) {
         return taskRepository.findTasksByStatus(status);
     }
 
     @Transactional
-    public Optional<Task> completeTask(String id) {
-        return taskRepository.findById(id).map(task -> {
-            task.setStatus(DONE);
-            return task;
-        });
+    public Task completeTask(String id) {
+        Task task = taskRepository.findById(id)
+                .orElseThrow(() -> new TaskNotFoundException(id));
+        task.setStatus(DONE);
+        return task;
     }
 
     @Transactional
-    public Optional<Task> deleteTask(String id) {
-        return taskRepository.findById(id).map(task -> {
-            if (task.getStatus() == DELETED) {
-                logger.info("Task '{}' is already deleted", task.getName());
-            } else {
-                task.setStatus(DELETED); // soft delete
-                logger.info("Task '{}' has been deleted", task.getName());
-            }
-            return task;
-        });
+    public Task deleteTask(String id) {
+        Task task = taskRepository.findById(id)
+                .orElseThrow(() -> new TaskNotFoundException(id));
+        task.setStatus(DELETED);
+        return task;
     }
 
     @Transactional
-    public Optional<Task> undoDelete(String id) {
-        return taskRepository.findById(id).map(task -> {
-            if (task.getStatus() == DELETED) {
-                task.setStatus(CREATED);
-                logger.info("Task '{}' reactivated", task.getName());
-            } else {
-                logger.info("Task '{}' could not be reactivated", task.getName());
-            }
-            return task;
-        });
+    public Task undoDelete(String id) {
+        Task task = taskRepository.findById(id)
+                .orElseThrow(() -> new TaskNotFoundException(id));
+
+        task.setStatus(CREATED);
+        return task;
     }
 }