Building REST APIs with Spring MVC

# Each request is independent — the server does not remember previous requests
GET /api/users/1    → Server responds with user data
GET /api/users/1    → Server responds the same way (it did not "remember" the first request)

# Use nouns, not verbs — the HTTP method IS the verb
✅ GET /api/posts          (get all posts)
❌ GET /api/getPosts       (redundant — GET already means "get")
❌ GET /api/posts/getAll   (redundant)

# Use plural nouns for collections
✅ /api/posts
✅ /api/users
❌ /api/post               (singular feels inconsistent)

# Use path variables for specific resources
✅ GET /api/posts/42       (get post with ID 42)

# Use query parameters for filtering, sorting, and pagination
✅ GET /api/posts?status=published&sort=date&page=2

# Use nesting for sub-resources (relationships)
✅ GET /api/posts/42/comments       (all comments on post 42)
✅ GET /api/posts/42/comments/7     (comment 7 on post 42)

# Keep URLs lowercase, use hyphens for multi-word resources
✅ /api/blog-posts
❌ /api/BlogPosts
❌ /api/blog_posts

@Controller
public class PageController {

    // Spring looks for a template named "home" (e.g., home.html in the templates folder)
    // and renders it as an HTML page.
    @GetMapping("/home")
    public String homePage(Model model) {
        model.addAttribute("title", "Welcome to My Blog");
        model.addAttribute("posts", postService.getRecentPosts());
        return "home";  // This is a VIEW NAME, not data
    }
}

@RestController
public class PostApiController {

    // The return value (a List of Post objects) is automatically 
    // serialized to JSON and written to the response body.
    @GetMapping("/api/posts")
    public List<Post> getAllPosts() {
        return postService.getAllPosts();  // This is DATA, not a view name
    }
}

// Using @RestController (the shortcut)
@RestController
public class PostApiController {

    @GetMapping("/api/posts")
    public List<Post> getAllPosts() {
        return postService.getAllPosts();
    }
}

// Using @Controller + @ResponseBody (the long way)
@Controller
@ResponseBody
public class PostApiController {

    @GetMapping("/api/posts")
    public List<Post> getAllPosts() {
        return postService.getAllPosts();
    }
}

@Controller
public class HybridController {

    // Returns an HTML view
    @GetMapping("/dashboard")
    public String dashboard() {
        return "dashboard";
    }

    // Returns JSON data (because of @ResponseBody)
    @GetMapping("/api/stats")
    @ResponseBody
    public Map<String, Object> getStats() {
        return Map.of("users", 150, "posts", 340);
    }
}

@RestController
@RequestMapping("/api/posts")  // Base path for all methods in this controller
public class PostController {

    @GetMapping              // GET /api/posts
    public List<Post> getAll() { ... }

    @GetMapping("/{id}")     // GET /api/posts/42
    public Post getById(@PathVariable Long id) { ... }

    @PostMapping             // POST /api/posts
    public Post create(@RequestBody Post post) { ... }

    @PutMapping("/{id}")     // PUT /api/posts/42
    public Post update(@PathVariable Long id, @RequestBody Post post) { ... }

    @PatchMapping("/{id}")   // PATCH /api/posts/42
    public Post partialUpdate(@PathVariable Long id, @RequestBody Map<String, Object> updates) { ... }

    @DeleteMapping("/{id}")  // DELETE /api/posts/42
    public void delete(@PathVariable Long id) { ... }
}

// These are equivalent:
@GetMapping("/api/posts")
@RequestMapping(value = "/api/posts", method = RequestMethod.GET)

// These are equivalent:
@PostMapping("/api/posts")
@RequestMapping(value = "/api/posts", method = RequestMethod.POST)

// This method handles both /api/posts and /api/articles
@GetMapping({"/api/posts", "/api/articles"})
public List<Post> getAll() { ... }

// Only accepts JSON input and returns JSON output
@PostMapping(
    value = "/api/posts",
    consumes = "application/json",  // Only accepts JSON request body
    produces = "application/json"   // Only returns JSON responses
)
public Post create(@RequestBody Post post) { ... }

GET /api/users/42          → 42 is a path variable (the user's ID)
GET /api/posts/15/comments → 15 is a path variable (the post's ID)

@RestController
@RequestMapping("/api/users")
public class UserController {

    // Single path variable
    // URL: GET /api/users/42
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        // id = 42
        return userService.getUserById(id);
    }

    // Multiple path variables
    // URL: GET /api/users/42/posts/15
    @GetMapping("/{userId}/posts/{postId}")
    public Post getUserPost(
            @PathVariable Long userId,
            @PathVariable Long postId) {
        // userId = 42, postId = 15
        return postService.getPostByUserAndId(userId, postId);
    }

    // Path variable with a different name than the method parameter
    // URL: GET /api/users/42
    @GetMapping("/{user_id}")
    public User getUser(@PathVariable("user_id") Long userId) {
        // The @PathVariable annotation maps {user_id} in the URL 
        // to the userId parameter in Java
        return userService.getUserById(userId);
    }
}

GET /api/posts?status=published              → filter by status
GET /api/posts?sort=date&order=desc          → sort by date descending
GET /api/posts?page=2&size=10                → pagination
GET /api/posts?status=published&sort=date    → combine multiple parameters

@RestController
@RequestMapping("/api/posts")
public class PostController {

    // Required query parameter
    // URL: GET /api/posts/search?keyword=spring
    // If keyword is missing, Spring returns 400 Bad Request
    @GetMapping("/search")
    public List<Post> search(@RequestParam String keyword) {
        return postService.searchByKeyword(keyword);
    }

    // Optional query parameter with a default value
    // URL: GET /api/posts?page=2&size=20
    // URL: GET /api/posts (uses defaults: page=0, size=10)
    @GetMapping
    public List<Post> getAllPosts(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size) {
        return postService.getPosts(page, size);
    }

    // Explicitly optional parameter (can be null)
    // URL: GET /api/posts/filter?status=published
    // URL: GET /api/posts/filter (status will be null)
    @GetMapping("/filter")
    public List<Post> filterPosts(
            @RequestParam(required = false) String status,
            @RequestParam(required = false) String category) {
        return postService.filterPosts(status, category);
    }

    // Receiving a list of values
    // URL: GET /api/posts/by-tags?tags=java&tags=spring&tags=boot
    // Also works: GET /api/posts/by-tags?tags=java,spring,boot
    @GetMapping("/by-tags")
    public List<Post> getPostsByTags(@RequestParam List<String> tags) {
        // tags = ["java", "spring", "boot"]
        return postService.getPostsByTags(tags);
    }
}

@RestController
@RequestMapping("/api/posts")
public class PostController {

    // The client sends JSON in the request body:
    // {
    //   "title": "Learning Spring Boot",
    //   "content": "Spring Boot makes Java web development easy...",
    //   "category": "TUTORIAL"
    // }
    //
    // Spring reads this JSON, creates a Post object, and populates its fields.
    // This process is called DESERIALIZATION (JSON → Java object).
    @PostMapping
    public Post createPost(@RequestBody Post post) {
        // At this point, post.getTitle() = "Learning Spring Boot"
        // post.getContent() = "Spring Boot makes Java web development easy..."
        // post.getCategory() = "TUTORIAL"
        return postService.createPost(post);
    }
}

public class Post {

    private Long id;
    private String title;
    private String content;
    private String category;

    // Default constructor — REQUIRED for Jackson deserialization
    public Post() {
    }

    // Getters — REQUIRED for Jackson serialization (Java → JSON)
    public Long getId() { return id; }
    public String getTitle() { return title; }
    public String getContent() { return content; }
    public String getCategory() { return category; }

    // Setters — REQUIRED for Jackson deserialization (JSON → Java)
    public void setId(Long id) { this.id = id; }
    public void setTitle(String title) { this.title = title; }
    public void setContent(String content) { this.content = content; }
    public void setCategory(String category) { this.category = category; }
}

@PostMapping("/api/feedback")
public Map<String, String> submitFeedback(@RequestBody Map<String, String> feedback) {
    String name = feedback.get("name");
    String message = feedback.get("message");
    // Process feedback...
    return Map.of("status", "received");
}

// Client sends:
{
  "title": "My Post",
  "content": "Hello",
  "unknownField": "this will be ignored"
}
// Jackson maps title and content, ignores unknownField. No error.

// Client sends:
{
  "title": "My Post"
}
// Jackson maps title = "My Post", content = null, category = null

// PUT /api/posts/42
// Request body: { "title": "Updated Title", "content": "Updated content" }
@PutMapping("/{id}")
public Post updatePost(
        @PathVariable Long id,           // From the URL path
        @RequestBody Post updatedPost) { // From the request body
    return postService.updatePost(id, updatedPost);
}

@RestController
@RequestMapping("/api/posts")
public class PostController {

    private final PostService postService;

    public PostController(PostService postService) {
        this.postService = postService;
    }

    // GET /api/posts — Returns 200 OK with the list
    // Spring returns 200 by default, so no ResponseEntity needed here
    @GetMapping
    public List<Post> getAllPosts() {
        return postService.getAllPosts();
    }

    // GET /api/posts/42 — Returns 200 OK or 404 Not Found
    @GetMapping("/{id}")
    public ResponseEntity<Post> getPostById(@PathVariable Long id) {
        // Try to find the post
        return postService.findById(id)
                // If found, return 200 OK with the post
                .map(post -> ResponseEntity.ok(post))
                // If not found, return 404 Not Found with no body
                .orElse(ResponseEntity.notFound().build());
    }

    // POST /api/posts — Returns 201 Created with the created post
    @PostMapping
    public ResponseEntity<Post> createPost(@RequestBody Post post) {
        Post created = postService.createPost(post);
        // Return 201 Created with the created post in the body
        return ResponseEntity
                .status(HttpStatus.CREATED)
                .body(created);
    }

    // PUT /api/posts/42 — Returns 200 OK with the updated post
    @PutMapping("/{id}")
    public ResponseEntity<Post> updatePost(
            @PathVariable Long id,
            @RequestBody Post post) {
        try {
            Post updated = postService.updatePost(id, post);
            return ResponseEntity.ok(updated);
        } catch (RuntimeException e) {
            return ResponseEntity.notFound().build();
        }
    }

    // DELETE /api/posts/42 — Returns 204 No Content
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deletePost(@PathVariable Long id) {
        try {
            postService.deletePost(id);
            // 204 No Content — successful deletion with no response body
            return ResponseEntity.noContent().build();
        } catch (RuntimeException e) {
            return ResponseEntity.notFound().build();
        }
    }
}

// 200 OK with body
ResponseEntity.ok(body)

// 200 OK with no body
ResponseEntity.ok().build()

// 201 Created with body
ResponseEntity.status(HttpStatus.CREATED).body(createdObject)

// 204 No Content
ResponseEntity.noContent().build()

// 400 Bad Request with body
ResponseEntity.badRequest().body(errorObject)

// 404 Not Found
ResponseEntity.notFound().build()

// Any status code
ResponseEntity.status(HttpStatus.CONFLICT).body(errorObject)
ResponseEntity.status(409).body(errorObject)

@PostMapping
public ResponseEntity<Post> createPost(@RequestBody Post post) {
    Post created = postService.createPost(post);
    
    // Build a URI for the created resource
    URI location = URI.create("/api/posts/" + created.getId());
    
    return ResponseEntity
            .created(location)           // 201 Created + Location header
            .header("X-Custom-Header", "my-value")  // Custom header
            .body(created);
}

# Client says: "I want JSON back" and "I'm sending JSON"
GET /api/posts HTTP/1.1
Accept: application/json
Content-Type: application/json

public class Post {
    private Long id;
    private String title;
    private String content;
    private LocalDateTime createdAt;

    // Jackson calls getId(), getTitle(), getContent(), getCreatedAt()
    // and creates a JSON object with those field names
    public Long getId() { return id; }
    public String getTitle() { return title; }
    public String getContent() { return content; }
    public LocalDateTime getCreatedAt() { return createdAt; }
}

{
  "id": 1,
  "title": "My First Post",
  "content": "Hello World",
  "createdAt": "2024-01-15T10:30:00"
}

public class Post {

    private Long id;
    private String title;
    private String content;
    private String internalNotes;
    private LocalDateTime createdAt;

    // @JsonProperty — changes the JSON field name.
    // Java uses camelCase, but your API might need snake_case.
    @JsonProperty("created_at")
    public LocalDateTime getCreatedAt() { return createdAt; }

    // @JsonIgnore — excludes this field from JSON completely.
    // Use for sensitive or internal data.
    @JsonIgnore
    public String getInternalNotes() { return internalNotes; }

    // Other getters...
    public Long getId() { return id; }
    public String getTitle() { return title; }
    public String getContent() { return content; }
}

{
  "id": 1,
  "title": "My First Post",
  "content": "Hello World",
  "created_at": "2024-01-15T10:30:00"
}
// Notice: "internalNotes" is NOT included (because of @JsonIgnore)
// Notice: "createdAt" is serialized as "created_at" (because of @JsonProperty)

// @JsonInclude — controls when null fields appear in JSON
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Post {
    // Fields with null values will be omitted from the JSON output
}

// @JsonFormat — controls date/time formatting
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime createdAt;
// Produces: "createdAt": "2024-01-15 10:30:00"

// @JsonIgnoreProperties — ignore unknown fields during deserialization
@JsonIgnoreProperties(ignoreUnknown = true)
public class Post {
    // If the client sends extra fields not in this class, Jackson ignores them
    // (This is actually the default behavior, but you can be explicit)
}

# Use snake_case for ALL JSON field names (instead of annotating every field)
spring.jackson.property-naming-strategy=SNAKE_CASE

# Pretty-print JSON (useful for development, disable in production)
spring.jackson.serialization.indent-output=true

# Do not fail on unknown properties (this is the default)
spring.jackson.deserialization.fail-on-unknown-properties=false

# Format dates globally
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=UTC

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

// Version 1 — returns basic user info
@RestController
@RequestMapping("/api/v1/users")
public class UserControllerV1 {

    @GetMapping("/{id}")
    public Map<String, Object> getUser(@PathVariable Long id) {
        // V1 response format
        return Map.of(
            "id", id,
            "name", "Alice",
            "email", "alice@example.com"
        );
    }
}

// Version 2 — returns extended user info with different structure
@RestController
@RequestMapping("/api/v2/users")
public class UserControllerV2 {

    @GetMapping("/{id}")
    public Map<String, Object> getUser(@PathVariable Long id) {
        // V2 response format — different structure
        return Map.of(
            "id", id,
            "profile", Map.of(
                "firstName", "Alice",
                "lastName", "Smith",
                "email", "alice@example.com"
            ),
            "metadata", Map.of(
                "createdAt", "2024-01-15",
                "lastLogin", "2024-06-20"
            )
        );
    }
}

GET /api/v1/users/42  → old format
GET /api/v2/users/42  → new format

@RestController
@RequestMapping("/api/users")
public class UserController {

    // Matches when X-API-Version header is "1"
    @GetMapping(value = "/{id}", headers = "X-API-Version=1")
    public Map<String, Object> getUserV1(@PathVariable Long id) {
        return Map.of("name", "Alice", "email", "alice@example.com");
    }

    // Matches when X-API-Version header is "2"
    @GetMapping(value = "/{id}", headers = "X-API-Version=2")
    public Map<String, Object> getUserV2(@PathVariable Long id) {
        return Map.of("profile", Map.of("firstName", "Alice", "lastName", "Smith"));
    }
}

GET /api/users/42
X-API-Version: 2

@RestController
@RequestMapping("/api/users")
public class UserController {

    @GetMapping(value = "/{id}", params = "version=1")
    public Map<String, Object> getUserV1(@PathVariable Long id) { ... }

    @GetMapping(value = "/{id}", params = "version=2")
    public Map<String, Object> getUserV2(@PathVariable Long id) { ... }
}

GET /api/users/42?version=2

package com.example.blogapi.model;

import com.fasterxml.jackson.annotation.JsonInclude;
import java.time.LocalDateTime;

// @JsonInclude(NON_NULL) means: if a field is null, do not include it 
// in the JSON response. This keeps responses clean.
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Post {

    private Long id;
    private String title;
    private String content;
    private String category;
    private String status;          // "DRAFT" or "PUBLISHED"
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;

    // Default constructor for Jackson deserialization
    public Post() {
    }

    // Constructor for convenience when creating posts in code
    public Post(String title, String content, String category) {
        this.title = title;
        this.content = content;
        this.category = category;
        this.status = "DRAFT";
        this.createdAt = LocalDateTime.now();
    }

    // --- Getters and Setters ---
    // Jackson uses getters for serialization (Java → JSON)
    // and setters for deserialization (JSON → Java)

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }

    public String getContent() { return content; }
    public void setContent(String content) { this.content = content; }

    public String getCategory() { return category; }
    public void setCategory(String category) { this.category = category; }

    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }

    public LocalDateTime getCreatedAt() { return createdAt; }
    public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }

    public LocalDateTime getUpdatedAt() { return updatedAt; }
    public void setUpdatedAt(LocalDateTime updatedAt) { this.updatedAt = updatedAt; }

    @Override
    public String toString() {
        return "Post{id=" + id + ", title='" + title + "', status='" + status + "'}";
    }
}

package com.example.blogapi.repository;

import com.example.blogapi.model.Post;
import org.springframework.stereotype.Repository;

import java.util.*;
import java.util.stream.Collectors;

@Repository
public class PostRepository {

    // In-memory storage — simulates a database table.
    // We use a Map instead of a List for efficient lookup by ID.
    // In Lecture 5, this will be replaced by Spring Data JPA.
    private final Map<Long, Post> posts = new HashMap<>();
    private long nextId = 1;

    // CREATE — equivalent to SQL: INSERT INTO posts (...) VALUES (...)
    public Post save(Post post) {
        if (post.getId() == null) {
            // New post — assign an ID
            post.setId(nextId++);
        }
        // Store or update the post in our "database"
        posts.put(post.getId(), post);
        return post;
    }

    // READ ONE — equivalent to SQL: SELECT * FROM posts WHERE id = ?
    public Optional<Post> findById(Long id) {
        return Optional.ofNullable(posts.get(id));
    }

    // READ ALL — equivalent to SQL: SELECT * FROM posts
    public List<Post> findAll() {
        return new ArrayList<>(posts.values());
    }

    // READ FILTERED — equivalent to SQL: SELECT * FROM posts WHERE status = ?
    public List<Post> findByStatus(String status) {
        return posts.values().stream()
                .filter(post -> post.getStatus().equalsIgnoreCase(status))
                .collect(Collectors.toList());
    }

    // READ FILTERED — equivalent to SQL: SELECT * FROM posts WHERE category = ?
    public List<Post> findByCategory(String category) {
        return posts.values().stream()
                .filter(post -> post.getCategory().equalsIgnoreCase(category))
                .collect(Collectors.toList());
    }

    // SEARCH — equivalent to SQL: SELECT * FROM posts 
    //          WHERE LOWER(title) LIKE '%keyword%' OR LOWER(content) LIKE '%keyword%'
    public List<Post> searchByKeyword(String keyword) {
        String lowerKeyword = keyword.toLowerCase();
        return posts.values().stream()
                .filter(post ->
                    post.getTitle().toLowerCase().contains(lowerKeyword) ||
                    post.getContent().toLowerCase().contains(lowerKeyword))
                .collect(Collectors.toList());
    }

    // DELETE — equivalent to SQL: DELETE FROM posts WHERE id = ?
    public boolean deleteById(Long id) {
        return posts.remove(id) != null;
    }

    // EXISTS — equivalent to SQL: SELECT EXISTS(SELECT 1 FROM posts WHERE id = ?)
    public boolean existsById(Long id) {
        return posts.containsKey(id);
    }

    // COUNT — equivalent to SQL: SELECT COUNT(*) FROM posts
    public long count() {
        return posts.size();
    }
}

package com.example.blogapi.service;

import com.example.blogapi.model.Post;
import com.example.blogapi.repository.PostRepository;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.List;

@Service
public class PostService {

    private final PostRepository postRepository;

    // Constructor injection — Spring provides the PostRepository bean
    public PostService(PostRepository postRepository) {
        this.postRepository = postRepository;
    }

    // CREATE — with validation and business logic
    public Post createPost(Post post) {
        // --- Business Rules ---

        // Rule: Title is required
        if (post.getTitle() == null || post.getTitle().trim().isEmpty()) {
            throw new IllegalArgumentException("Post title cannot be empty");
        }

        // Rule: Content is required
        if (post.getContent() == null || post.getContent().trim().isEmpty()) {
            throw new IllegalArgumentException("Post content cannot be empty");
        }

        // Rule: Trim whitespace
        post.setTitle(post.getTitle().trim());
        post.setContent(post.getContent().trim());

        // Rule: Default status is DRAFT
        if (post.getStatus() == null) {
            post.setStatus("DRAFT");
        }

        // Rule: Set creation timestamp
        post.setCreatedAt(LocalDateTime.now());

        return postRepository.save(post);
    }

    // READ ONE — with not-found handling
    public Post getPostById(Long id) {
        return postRepository.findById(id)
                .orElseThrow(() -> new RuntimeException(
                        "Post not found with id: " + id));
    }

    // READ ALL — with optional filtering
    public List<Post> getAllPosts(String status, String category) {
        if (status != null && !status.isEmpty()) {
            return postRepository.findByStatus(status);
        }
        if (category != null && !category.isEmpty()) {
            return postRepository.findByCategory(category);
        }
        return postRepository.findAll();
    }

    // SEARCH
    public List<Post> searchPosts(String keyword) {
        if (keyword == null || keyword.trim().isEmpty()) {
            throw new IllegalArgumentException("Search keyword cannot be empty");
        }
        return postRepository.searchByKeyword(keyword.trim());
    }

    // UPDATE (full replacement) — PUT semantics
    public Post updatePost(Long id, Post updatedPost) {
        // Verify the post exists
        Post existingPost = postRepository.findById(id)
                .orElseThrow(() -> new RuntimeException(
                        "Post not found with id: " + id));

        // Validate the updated data
        if (updatedPost.getTitle() == null || updatedPost.getTitle().trim().isEmpty()) {
            throw new IllegalArgumentException("Post title cannot be empty");
        }
        if (updatedPost.getContent() == null || updatedPost.getContent().trim().isEmpty()) {
            throw new IllegalArgumentException("Post content cannot be empty");
        }

        // Update all fields (PUT = full replacement)
        existingPost.setTitle(updatedPost.getTitle().trim());
        existingPost.setContent(updatedPost.getContent().trim());
        existingPost.setCategory(updatedPost.getCategory());
        existingPost.setStatus(updatedPost.getStatus());
        existingPost.setUpdatedAt(LocalDateTime.now());

        return postRepository.save(existingPost);
    }

    // PARTIAL UPDATE — PATCH semantics
    public Post partialUpdatePost(Long id, Post partialPost) {
        Post existingPost = postRepository.findById(id)
                .orElseThrow(() -> new RuntimeException(
                        "Post not found with id: " + id));

        // Only update fields that are provided (non-null)
        // This is the key difference between PUT and PATCH:
        // PUT replaces everything; PATCH updates only what is provided.
        if (partialPost.getTitle() != null) {
            existingPost.setTitle(partialPost.getTitle().trim());
        }
        if (partialPost.getContent() != null) {
            existingPost.setContent(partialPost.getContent().trim());
        }
        if (partialPost.getCategory() != null) {
            existingPost.setCategory(partialPost.getCategory());
        }
        if (partialPost.getStatus() != null) {
            existingPost.setStatus(partialPost.getStatus());
        }

        existingPost.setUpdatedAt(LocalDateTime.now());
        return postRepository.save(existingPost);
    }

    // DELETE
    public void deletePost(Long id) {
        if (!postRepository.existsById(id)) {
            throw new RuntimeException("Post not found with id: " + id);
        }
        postRepository.deleteById(id);
    }

    // COUNT
    public long getPostCount() {
        return postRepository.count();
    }
}

package com.example.blogapi.controller;

import com.example.blogapi.model.Post;
import com.example.blogapi.service.PostService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/posts")
public class PostController {

    private final PostService postService;

    public PostController(PostService postService) {
        this.postService = postService;
    }

    // ==================== CREATE ====================

    // POST /api/posts
    // Request body: { "title": "...", "content": "...", "category": "..." }
    // Returns: 201 Created with the created post
    @PostMapping
    public ResponseEntity<Post> createPost(@RequestBody Post post) {
        Post created = postService.createPost(post);
        return ResponseEntity.status(HttpStatus.CREATED).body(created);
    }

    // ==================== READ ====================

    // GET /api/posts
    // GET /api/posts?status=PUBLISHED
    // GET /api/posts?category=TUTORIAL
    // Returns: 200 OK with list of posts
    @GetMapping
    public List<Post> getAllPosts(
            @RequestParam(required = false) String status,
            @RequestParam(required = false) String category) {
        return postService.getAllPosts(status, category);
    }

    // GET /api/posts/42
    // Returns: 200 OK with the post, or 404 Not Found
    @GetMapping("/{id}")
    public ResponseEntity<Post> getPostById(@PathVariable Long id) {
        try {
            Post post = postService.getPostById(id);
            return ResponseEntity.ok(post);
        } catch (RuntimeException e) {
            return ResponseEntity.notFound().build();
        }
    }

    // GET /api/posts/search?keyword=spring
    // Returns: 200 OK with matching posts
    @GetMapping("/search")
    public ResponseEntity<?> searchPosts(@RequestParam String keyword) {
        try {
            List<Post> results = postService.searchPosts(keyword);
            return ResponseEntity.ok(results);
        } catch (IllegalArgumentException e) {
            // Return 400 Bad Request with error message
            Map<String, String> error = new HashMap<>();
            error.put("error", e.getMessage());
            return ResponseEntity.badRequest().body(error);
        }
    }

    // GET /api/posts/count
    // Returns: 200 OK with count
    @GetMapping("/count")
    public Map<String, Long> getPostCount() {
        return Map.of("count", postService.getPostCount());
    }

    // ==================== UPDATE ====================

    // PUT /api/posts/42
    // Request body: complete post data (full replacement)
    // Returns: 200 OK with updated post, or 404 Not Found
    @PutMapping("/{id}")
    public ResponseEntity<?> updatePost(
            @PathVariable Long id,
            @RequestBody Post post) {
        try {
            Post updated = postService.updatePost(id, post);
            return ResponseEntity.ok(updated);
        } catch (RuntimeException e) {
            Map<String, String> error = new HashMap<>();
            error.put("error", e.getMessage());
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
        } catch (IllegalArgumentException e) {
            Map<String, String> error = new HashMap<>();
            error.put("error", e.getMessage());
            return ResponseEntity.badRequest().body(error);
        }
    }

    // PATCH /api/posts/42
    // Request body: partial post data (only fields to update)
    // Returns: 200 OK with updated post, or 404 Not Found
    @PatchMapping("/{id}")
    public ResponseEntity<?> partialUpdatePost(
            @PathVariable Long id,
            @RequestBody Post post) {
        try {
            Post updated = postService.partialUpdatePost(id, post);
            return ResponseEntity.ok(updated);
        } catch (RuntimeException e) {
            Map<String, String> error = new HashMap<>();
            error.put("error", e.getMessage());
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
        }
    }

    // ==================== DELETE ====================

    // DELETE /api/posts/42
    // Returns: 204 No Content, or 404 Not Found
    @DeleteMapping("/{id}")
    public ResponseEntity<?> deletePost(@PathVariable Long id) {
        try {
            postService.deletePost(id);
            return ResponseEntity.noContent().build();
        } catch (RuntimeException e) {
            Map<String, String> error = new HashMap<>();
            error.put("error", e.getMessage());
            return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
        }
    }
}

# Create post 1
curl -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Getting Started with Spring Boot",
    "content": "Spring Boot is a framework that simplifies Java web development...",
    "category": "TUTORIAL"
  }'

# Expected: 201 Created
# {
#   "id": 1,
#   "title": "Getting Started with Spring Boot",
#   "content": "Spring Boot is a framework...",
#   "category": "TUTORIAL",
#   "status": "DRAFT",
#   "createdAt": "2024-01-15T10:30:00"
# }

# Create post 2
curl -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Understanding REST APIs",
    "content": "REST stands for Representational State Transfer...",
    "category": "TUTORIAL",
    "status": "PUBLISHED"
  }'

# Create post 3
curl -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Java 17 New Features",
    "content": "Java 17 introduced sealed classes, pattern matching...",
    "category": "NEWS"
  }'

# Get all posts
curl http://localhost:8080/api/posts

# Get a specific post
curl http://localhost:8080/api/posts/1

# Get a non-existent post (should return 404)
curl -v http://localhost:8080/api/posts/999

# Filter by status
curl http://localhost:8080/api/posts?status=PUBLISHED

# Filter by category
curl http://localhost:8080/api/posts?category=TUTORIAL

# Search by keyword
curl http://localhost:8080/api/posts/search?keyword=spring

# Get post count
curl http://localhost:8080/api/posts/count

# Full update (PUT) — replace all fields of post 1
curl -X PUT http://localhost:8080/api/posts/1 \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Getting Started with Spring Boot 3",
    "content": "Spring Boot 3 requires Java 17 and brings Jakarta EE...",
    "category": "TUTORIAL",
    "status": "PUBLISHED"
  }'

# Expected: 200 OK with updatedAt timestamp set

# Partial update (PATCH) — only update the status of post 3
curl -X PATCH http://localhost:8080/api/posts/3 \
  -H "Content-Type: application/json" \
  -d '{
    "status": "PUBLISHED"
  }'

# Expected: 200 OK — only status changed, title and content unchanged

# Delete post 2
curl -X DELETE http://localhost:8080/api/posts/2 -v

# Expected: 204 No Content (empty response body)

# Try to delete a non-existent post
curl -X DELETE http://localhost:8080/api/posts/999 -v

# Expected: 404 Not Found with error message

# Try to create a post with empty title
curl -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -d '{
    "title": "",
    "content": "Some content"
  }'

# Expected: 500 Internal Server Error (we will improve this in Lecture 8)

{
  "id": 1,
  "title": "Original Title",
  "content": "Original content",
  "category": "TUTORIAL",
  "status": "DRAFT"
}

{
  "title": "New Title",
  "content": "New content",
  "category": "NEWS",
  "status": "PUBLISHED"
}
// Result: ALL fields are replaced with the new values

{
  "title": "New Title",
  "content": "New content"
}
// Result: category = null, status = null (because they were not provided)

{
  "status": "PUBLISHED"
}
// Result: Only status changes. Title, content, and category remain unchanged.