Mini-challenge: TaskFlow REST API v1 — capstone Module 03

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springdoc</groupId>
        <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
        <version>2.6.0</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

public record Project(
    Long id,
    String name,
    String description,
    ProjectStatus status,
    Instant createdAt
) {}

public enum ProjectStatus { PLANNING, ACTIVE, DONE, ARCHIVED }

@Schema(description = "Create project request")
public record CreateProjectRequest(

    @Schema(description = "Project name (unique)", example = "Mobile App Redesign", minLength = 3, maxLength = 100)
    @NotBlank @Size(min = 3, max = 100)
    String name,

    @Schema(description = "Project description", example = "Redesign mobile app for v3", maxLength = 500)
    @Size(max = 500)
    String description,

    @Schema(description = "Initial status", example = "PLANNING")
    ProjectStatus status
) {
    public CreateProjectRequest {
        if (status == null) status = ProjectStatus.PLANNING;
    }
}

@Service
@Slf4j
public class ProjectService {

    private final ProjectRepository repo;
    private final TaskRepository taskRepo;

    public ProjectService(ProjectRepository repo, TaskRepository taskRepo) {
        this.repo = repo;
        this.taskRepo = taskRepo;
    }

    public Project create(CreateProjectRequest req) {
        if (repo.existsByName(req.name())) {
            throw new DuplicateProjectNameException(req.name());
        }
        Project project = new Project(
            null,                                  // ID auto-gen
            req.name(),
            req.description(),
            req.status(),
            Instant.now()
        );
        Project saved = repo.save(project);
        log.info("Created project {}", saved.id());
        return saved;
    }

    public Project findById(Long id) {
        return repo.findById(id)
            .orElseThrow(() -> new ProjectNotFoundException(id));
    }

    public Page<Project> list(ProjectStatus status, Pageable pageable) {
        return repo.findByStatus(status, pageable);
    }

    public Project update(Long id, UpdateProjectRequest req) {
        Project existing = findById(id);
        if (!existing.name().equals(req.name()) && repo.existsByName(req.name())) {
            throw new DuplicateProjectNameException(req.name());
        }
        Project updated = new Project(
            id,
            req.name(),
            req.description(),
            req.status(),
            existing.createdAt()
        );
        return repo.save(updated);
    }

    @Transactional
    public void delete(Long id) {
        Project project = findById(id);
        taskRepo.deleteByProjectId(id);          // cascade
        repo.delete(id);
        log.info("Deleted project {} with {} tasks", id, taskRepo.countByProjectId(id));
    }
}

@RestController
@RequestMapping("/api/v1/projects")
@Tag(name = "Projects", description = "Project management")
@Validated
public class ProjectController {

    private final ProjectService service;

    public ProjectController(ProjectService service) {
        this.service = service;
    }

    @Operation(summary = "Create project")
    @PostMapping
    public ResponseEntity<ProjectDto> create(@Valid @RequestBody CreateProjectRequest req) {
        Project created = service.create(req);
        URI location = ServletUriComponentsBuilder.fromCurrentRequest()
            .path("/{id}").buildAndExpand(created.id()).toUri();
        return ResponseEntity.created(location).body(ProjectDto.from(created));
    }

    @Operation(summary = "List projects")
    @GetMapping
    public Page<ProjectDto> list(
        @Parameter(example = "ACTIVE")
        @RequestParam(required = false) ProjectStatus status,
        @Parameter(example = "0") @Min(0)
        @RequestParam(defaultValue = "0") int page,
        @Parameter(example = "20") @Min(1) @Max(100)
        @RequestParam(defaultValue = "20") int size
    ) {
        return service.list(status, PageRequest.of(page, size))
            .map(ProjectDto::from);
    }

    @Operation(summary = "Get project by ID")
    @GetMapping("/{id}")
    public ProjectDto get(@PathVariable Long id) {
        return ProjectDto.from(service.findById(id));
    }

    @Operation(summary = "Update project")
    @PutMapping("/{id}")
    public ProjectDto update(@PathVariable Long id,
                              @Valid @RequestBody UpdateProjectRequest req) {
        return ProjectDto.from(service.update(id, req));
    }

    @Operation(summary = "Delete project (cascade tasks)")
    @ApiResponse(responseCode = "204", description = "Deleted successfully")
    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void delete(@PathVariable Long id) {
        service.delete(id);
    }
}

@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

    @ExceptionHandler(ProjectNotFoundException.class)
    public ProblemDetail handleProjectNotFound(ProjectNotFoundException ex, HttpServletRequest req) {
        ProblemDetail pd = ProblemDetail.forStatus(HttpStatus.NOT_FOUND);
        pd.setTitle("Project not found");
        pd.setDetail(ex.getMessage());
        pd.setInstance(URI.create(req.getRequestURI()));
        pd.setProperty("projectId", ex.getProjectId());
        return pd;
    }

    @ExceptionHandler(TaskNotFoundException.class)
    public ProblemDetail handleTaskNotFound(TaskNotFoundException ex, HttpServletRequest req) {
        ProblemDetail pd = ProblemDetail.forStatus(HttpStatus.NOT_FOUND);
        pd.setTitle("Task not found");
        pd.setDetail(ex.getMessage());
        pd.setInstance(URI.create(req.getRequestURI()));
        pd.setProperty("taskId", ex.getTaskId());
        return pd;
    }

    @ExceptionHandler(DuplicateProjectNameException.class)
    public ProblemDetail handleDuplicate(DuplicateProjectNameException ex, HttpServletRequest req) {
        ProblemDetail pd = ProblemDetail.forStatus(HttpStatus.CONFLICT);
        pd.setTitle("Project name already exists");
        pd.setDetail(ex.getMessage());
        pd.setInstance(URI.create(req.getRequestURI()));
        return pd;
    }

    @ExceptionHandler(InvalidStateTransitionException.class)
    public ProblemDetail handleInvalidTransition(InvalidStateTransitionException ex, HttpServletRequest req) {
        ProblemDetail pd = ProblemDetail.forStatus(HttpStatus.UNPROCESSABLE_ENTITY);
        pd.setTitle("Invalid state transition");
        pd.setDetail(ex.getMessage());
        pd.setInstance(URI.create(req.getRequestURI()));
        return pd;
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ProblemDetail handleValidation(MethodArgumentNotValidException ex, HttpServletRequest req) {
        ProblemDetail pd = ProblemDetail.forStatus(HttpStatus.BAD_REQUEST);
        pd.setTitle("Validation failed");
        pd.setDetail("Request has " + ex.getBindingResult().getErrorCount() + " invalid field(s)");
        pd.setInstance(URI.create(req.getRequestURI()));

        List<Map<String, Object>> violations = ex.getBindingResult().getFieldErrors().stream()
            .map(err -> Map.<String, Object>of(
                "field", err.getField(),
                "message", err.getDefaultMessage(),
                "rejectedValue", String.valueOf(err.getRejectedValue())
            ))
            .toList();
        pd.setProperty("violations", violations);

        return pd;
    }

    @ExceptionHandler(ConstraintViolationException.class)
    public ProblemDetail handleConstraintViolation(ConstraintViolationException ex, HttpServletRequest req) {
        ProblemDetail pd = ProblemDetail.forStatus(HttpStatus.BAD_REQUEST);
        pd.setTitle("Validation failed");
        pd.setDetail("Request parameter validation failed");
        pd.setInstance(URI.create(req.getRequestURI()));

        List<Map<String, Object>> violations = ex.getConstraintViolations().stream()
            .map(v -> Map.<String, Object>of(
                "path", v.getPropertyPath().toString(),
                "message", v.getMessage(),
                "rejectedValue", String.valueOf(v.getInvalidValue())
            ))
            .toList();
        pd.setProperty("violations", violations);

        return pd;
    }

    @ExceptionHandler(Exception.class)
    public ProblemDetail handleAll(Exception ex, HttpServletRequest req) {
        String requestId = MDC.get("requestId");
        log.error("Unhandled exception, requestId={}, path={}", requestId, req.getRequestURI(), ex);

        ProblemDetail pd = ProblemDetail.forStatus(HttpStatus.INTERNAL_SERVER_ERROR);
        pd.setTitle("Internal server error");
        pd.setDetail("An unexpected error occurred. Contact support with request ID.");
        pd.setInstance(URI.create(req.getRequestURI()));
        pd.setProperty("requestId", requestId);
        return pd;
    }
}

@Component
@Slf4j
public class LoggingFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        String requestId = req.getHeader("X-Request-Id");
        if (requestId == null) {
            requestId = UUID.randomUUID().toString().substring(0, 8);
        }

        long start = System.currentTimeMillis();

        try (MDC.MDCCloseable mdc = MDC.putCloseable("requestId", requestId)) {
            log.info(">>> {} {}", req.getMethod(), req.getRequestURI());
            res.setHeader("X-Request-Id", requestId);

            chain.doFilter(req, res);

            long elapsed = System.currentTimeMillis() - start;
            log.info("<<< {} in {}ms", res.getStatus(), elapsed);
        }
    }
}

server:
  port: 8080
  shutdown: graceful

spring:
  application:
    name: taskflow-api
  mvc:
    problemdetails:
      enabled: true
  lifecycle:
    timeout-per-shutdown-phase: 30s

logging:
  level:
    com.olhub.taskflow: DEBUG
  pattern:
    console: "%d{HH:mm:ss.SSS} [%thread] %-5level [%X{requestId:-no-req}] %logger{30} : %msg%n"

springdoc:
  api-docs:
    path: /v3/api-docs
  swagger-ui:
    path: /swagger-ui.html
    try-it-out-enabled: true

management:
  endpoints:
    web:
      exposure:
        include: health, info, conditions, mappings, loggers