Finishing Task 6

Author: jabrena

examples/spring-boot-demo/implementation/src/main/java/com/example/demo/controller/FilmController.java

@@ -9,7 +9,8 @@
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ProblemDetail;
 import com.example.demo.service.FilmService;
-import com.example.demo.dto.FilmResponse;
+import com.example.demo.dto.FilmDTO;
+import com.example.demo.entity.Film;
 
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
@@ -92,7 +93,7 @@ public FilmController(FilmService filmService) {
             description = "Successfully retrieved films",
             content = @Content(
                 mediaType = "application/json",
-                schema = @Schema(implementation = FilmResponse.class)
+                schema = @Schema(implementation = FilmDTO.class)
             )
         ),
         @ApiResponse(
@@ -131,18 +132,18 @@ public ResponseEntity<?> getFilms(
             }
         }
 
-        // Call service layer to get films
-        List<Map<String, Object>> films = filmService.findFilmsByStartingLetter(startsWith);
+        // Call service layer to get films as entities
+        List<Film> films = filmService.findFilmEntitiesByStartingLetter(startsWith);
 
         // Task 4.6: Implement response formatting with films array, count, and filter
         // Build filter object
         Map<String, Object> filter = new HashMap<>();
-        if (startsWith != null && !startsWith.trim().isEmpty()) {
+        if (Objects.nonNull(startsWith) && !startsWith.trim().isEmpty()) {
             filter.put("startsWith", startsWith);
         }
 
-        // Create FilmResponse DTO (Task 4.5)
-        FilmResponse response = new FilmResponse(films, films.size(), filter);
+        // Create FilmDTO response (Task 6.6)
+        FilmDTO response = FilmDTO.fromEntities(films, filter);
 
         // Task 4.8: Implement proper HTTP status code handling
         return ResponseEntity.ok(response);

examples/spring-boot-demo/implementation/src/main/java/com/example/demo/dto/FilmDTO.java

@@ -0,0 +1,97 @@
+package com.example.demo.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * FilmDTO - Comprehensive Data Transfer Object for Film Query API
+ * 
+ * Task 6.6: Create FilmDTO for data transfer ✅
+ * 
+ * This DTO represents the complete film query response, replacing FilmResponse.
+ * It provides a clean separation between entity and response formats.
+ * 
+ * Complete JSON structure:
+ * {
+ *   "films": [
+ *     {
+ *       "film_id": 1,
+ *       "title": "ACADEMY DINOSAUR"
+ *     }
+ *   ],
+ *   "count": 46,
+ *   "filter": {
+ *     "startsWith": "A"
+ *   }
+ * }
+ */
+public record FilmDTO(
+    @JsonProperty("films") List<Film> films,
+    @JsonProperty("count") int count,
+    @JsonProperty("filter") Map<String, Object> filter
+) {
+    
+    /**
+     * Individual Film record for the films array
+     */
+    public record Film(
+        @JsonProperty("film_id") Integer filmId,
+        @JsonProperty("title") String title
+    ) {
+        /**
+         * Factory method to create Film from Film entity
+         * 
+         * @param entity The Film entity to convert
+         * @return Film record with mapped data
+         */
+        public static Film fromEntity(com.example.demo.entity.Film entity) {
+            return new Film(entity.filmId(), entity.title());
+        }
+        
+        /**
+         * Convert Film to Map format for backward compatibility
+         * 
+         * @return Map representation of the film
+         */
+        public Map<String, Object> toMap() {
+            Map<String, Object> map = new java.util.HashMap<>();
+            map.put("film_id", filmId);
+            map.put("title", title);
+            return map;
+        }
+    }
+    
+    /**
+     * Factory method to create FilmDTO from film entities and filter
+     * 
+     * @param entities List of Film entities to convert
+     * @param filterMap Map containing filter parameters
+     * @return FilmDTO instance with complete response structure
+     */
+    public static FilmDTO fromEntities(List<com.example.demo.entity.Film> entities, Map<String, Object> filterMap) {
+        List<Film> films = entities.stream()
+                .map(Film::fromEntity)
+                .toList();
+        
+        return new FilmDTO(films, films.size(), filterMap);
+    }
+    
+    /**
+     * Factory method to create FilmDTO from Map-based films (for backward compatibility)
+     * 
+     * @param filmMaps List of film maps
+     * @param filterMap Map containing filter parameters
+     * @return FilmDTO instance with complete response structure
+     */
+    public static FilmDTO fromMaps(List<Map<String, Object>> filmMaps, Map<String, Object> filterMap) {
+        List<Film> films = filmMaps.stream()
+                .map(map -> new Film(
+                    (Integer) map.get("film_id"),
+                    (String) map.get("title")
+                ))
+                .toList();
+        
+        return new FilmDTO(films, films.size(), filterMap);
+    }
+} 

examples/spring-boot-demo/implementation/src/main/java/com/example/demo/dto/FilmResponse.java

@@ -33,19 +33,12 @@ public FilmService(FilmRepository filmRepository) {
     }
 
     /**
-     * Task 6.2: Implement findFilmsByStartingLetter(String letter) method ✅
-     * Task 6.3: Add business validation for letter parameter ✅ 
-     * Task 6.4: Implement film filtering logic (case insensitive LIKE query) ✅
-     * Task 6.7: Implement entity to DTO transformation logic ✅
-     * Task 6.8: Add empty result handling with appropriate messaging ✅
-     * 
-     * Retrieves films from the database that start with the specified letter.
-     * Handles both filtered queries (when letter is provided) and unfiltered queries.
+     * Get Film entities by starting letter (internal method for controller use)
      * 
      * @param letter Optional starting letter to filter films (A-Z, case insensitive)
-     * @return List of film maps with film_id and title, empty list if no matches
+     * @return List of Film entities, empty list if no matches
      */
-    public List<Map<String, Object>> findFilmsByStartingLetter(String letter) {
+    public List<Film> findFilmEntitiesByStartingLetter(String letter) {
         List<Film> films;
 
         // Task 6.3: Add business validation for letter parameter (already done in controller)
@@ -58,11 +51,8 @@ public List<Map<String, Object>> findFilmsByStartingLetter(String letter) {
             films = filmRepository.findAllOrderByTitle();
         }
 
-        // Task 6.7: Implement entity to DTO transformation logic
-        // Transform Film entities to Map<String, Object> format expected by controller
-        return films.stream()
-                .map(this::filmToMap)
-                .toList();
+        // Task 6.8: Add empty result handling with appropriate messaging
+        return films; // Return entities directly for DTO transformation in controller
     }
 
     /**