Merge branch 'dev-innovation-full-info' into dev

Author: kenjitm

src/main/java/com/example/demo/modules/innovationcomments/adapters/infrastructure/persistence/InnovationCatalogCommentJpaRepository.java

@@ -1,6 +1,7 @@
 package com.example.demo.modules.innovationcomments.adapters.infrastructure.persistence;
 
 import com.example.demo.modules.innovationcomments.domain.model.InnovationCatalogComment;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
@@ -81,6 +82,16 @@ public interface InnovationCatalogCommentJpaRepository extends JpaRepository<Inn
            "ORDER BY c.activeSince DESC")
     List<InnovationCatalogComment> findAllCommentsByInnovationId(@Param("innovationId") Long innovationId);
 
+    /**
+     * Finds all comments ordered by active since descending.
+     */
+    List<InnovationCatalogComment> findAllByOrderByActiveSinceDesc();
+    
+    /**
+     * Finds comments ordered by active since descending limited by pageable.
+     */
+    List<InnovationCatalogComment> findAllByOrderByActiveSinceDesc(Pageable pageable);
+    
     /**
      * Soft delete - marks comment as inactive instead of deleting it
      * Note: For update queries, we need @Modifying annotation
@@ -92,4 +103,4 @@ public interface InnovationCatalogCommentJpaRepository extends JpaRepository<Inn
            "SET c.isActive = false, c.activeSince = CURRENT_TIMESTAMP " +
            "WHERE c.id = :commentId")
     int softDeleteComment(@Param("commentId") Long commentId);
-}
+}

src/main/java/com/example/demo/modules/innovationcomments/adapters/infrastructure/persistence/InnovationCommentRepositoryAdapter.java

@@ -2,6 +2,7 @@
 
 import com.example.demo.modules.innovationcomments.domain.model.InnovationCatalogComment;
 import com.example.demo.modules.innovationcomments.domain.port.out.InnovationCommentRepository;
+import org.springframework.data.domain.PageRequest;
 import org.springframework.stereotype.Repository;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -62,6 +63,14 @@ public List<InnovationCatalogComment> findAllCommentsByInnovationId(Long innovat
         return jpaRepository.findAllCommentsByInnovationId(innovationId);
     }
 
+    @Override
+    public List<InnovationCatalogComment> findAllCommentsOrderByActiveSinceDesc(Integer limit) {
+        if (limit == null || limit <= 0) {
+            return jpaRepository.findAllByOrderByActiveSinceDesc();
+        }
+        return jpaRepository.findAllByOrderByActiveSinceDesc(PageRequest.of(0, limit));
+    }
+    
     @Override
     @Transactional
     public int softDeleteComment(Long commentId) {
@@ -73,4 +82,4 @@ public boolean existsActiveComment(Long commentId) {
         Optional<InnovationCatalogComment> comment = jpaRepository.findById(commentId);
         return comment.isPresent() && comment.get().getIsActive();
     }
-}
+}

src/main/java/com/example/demo/modules/innovationcomments/adapters/web/controller/InnovationCommentController.java

@@ -38,6 +38,40 @@ public InnovationCommentController(InnovationCommentUseCase commentUseCase,
         this.commentMapper = commentMapper;
     }
 
+    @Operation(
+        summary = "Get all comments",
+        description = "Retrieves all comments ordered by most recent first. Optionally limit the number of comments returned."
+    )
+    @ApiResponses(value = {
+        @ApiResponse(responseCode = "200", description = "Successfully retrieved comments"),
+        @ApiResponse(responseCode = "400", description = "Invalid limit parameter"),
+        @ApiResponse(responseCode = "503", description = "Comments table unavailable"),
+        @ApiResponse(responseCode = "500", description = "Internal server error")
+    })
+    @GetMapping
+    public ResponseEntity<List<InnovationCommentResponseDto>> getAllComments(
+            @Parameter(description = "Maximum number of comments to return", required = false, example = "10")
+            @RequestParam(value = "limit", required = false) Integer limit) {
+        
+        try {
+            List<InnovationCatalogComment> comments = commentUseCase.getAllComments(limit);
+            return ResponseEntity.ok(commentMapper.toResponseDtoList(comments));
+        } catch (IllegalArgumentException e) {
+            logger.warn("Invalid limit parameter provided: {}", e.getMessage());
+            return ResponseEntity.badRequest().build();
+        } catch (RuntimeException e) {
+            if (e.getMessage() != null && e.getMessage().contains("table not found")) {
+                logger.error("Database table not found: {}", e.getMessage());
+                return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).build();
+            }
+            logger.error("Error fetching comments: {}", e.getMessage());
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        } catch (Exception e) {
+            logger.error("Unexpected error fetching comments: {}", e.getMessage());
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+    
     @Operation(
         summary = "Get active comments by innovation ID",
         description = "Retrieves all active comments for a specific innovation, ordered by creation date descending"
@@ -213,4 +247,4 @@ public ResponseEntity<Void> deactivateComment(
 
 
 
-}
+}

src/main/java/com/example/demo/modules/innovationcomments/application/service/InnovationCommentService.java

@@ -149,6 +149,29 @@ public List<InnovationCatalogComment> getActiveCommentsByUserEmail(String userEm
         }
     }
 
+    @Override
+    @Transactional(readOnly = true)
+    public List<InnovationCatalogComment> getAllComments(Integer limit) {
+        Integer sanitizedLimit = null;
+        if (limit != null) {
+            if (limit <= 0) {
+                throw new IllegalArgumentException("Limit must be greater than zero");
+            }
+            sanitizedLimit = limit;
+        }
+        
+        try {
+            return commentRepository.findAllCommentsOrderByActiveSinceDesc(sanitizedLimit);
+        } catch (DataAccessException e) {
+            logger.error("Database error while fetching comments: {}", e.getMessage());
+            if (isTableNotExistsError(e)) {
+                logger.warn("Table 'innovation_catalog_comments' does not exist in database");
+                throw new RuntimeException("Comments table not found. Please ensure the database schema is properly initialized.", e);
+            }
+            throw new RuntimeException("Database error occurred while fetching comments", e);
+        }
+    }
+    
     @Override
     @Transactional(readOnly = true)
     public List<InnovationCatalogComment> getRecentActiveCommentsByInnovationId(Long innovationId) {
@@ -266,4 +289,4 @@ private boolean isTableNotExistsError(DataAccessException e) {
                 lowerCaseMessage.contains("unknown table") ||
                 lowerCaseMessage.contains("innovation_catalog_comments"));
     }
-}
+}

src/main/java/com/example/demo/modules/innovationcomments/domain/port/in/InnovationCommentUseCase.java

@@ -70,6 +70,13 @@ InnovationCatalogComment createCommentWithAudit(Long innovationId, String userNa
      */
     List<InnovationCatalogComment> getRecentActiveCommentsByInnovationId(Long innovationId);
 
+    /**
+     * Get all comments ordered by newest first, optionally limited.
+     * @param limit Maximum number of comments to return. Null means all.
+     * @return List of comments ordered by activeSince descending.
+     */
+    List<InnovationCatalogComment> getAllComments(Integer limit);
+    
     /**
      * Soft delete a comment (mark as inactive)
      * @param commentId The comment ID to deactivate
@@ -83,4 +90,4 @@ InnovationCatalogComment createCommentWithAudit(Long innovationId, String userNa
      * @return true if comment exists and is active
      */
     boolean isCommentActive(Long commentId);
-}
+}

src/main/java/com/example/demo/modules/innovationcomments/domain/port/out/InnovationCommentRepository.java

@@ -67,6 +67,13 @@ public interface InnovationCommentRepository {
      */
     List<InnovationCatalogComment> findAllCommentsByInnovationId(Long innovationId);
 
+    /**
+     * Find all comments ordered by activeSince descending, optionally limited.
+     * @param limit Maximum number of comments to return. If null, returns all.
+     * @return List of comments ordered by newest first.
+     */
+    List<InnovationCatalogComment> findAllCommentsOrderByActiveSinceDesc(Integer limit);
+    
     /**
      * Soft delete a comment by marking it as inactive
      * @param commentId The comment ID to deactivate
@@ -80,4 +87,4 @@ public interface InnovationCommentRepository {
      * @return true if comment exists and is active
      */
     boolean existsActiveComment(Long commentId);
-}
+}

src/test/java/com/example/demo/modules/innovationcomments/application/service/InnovationCommentServiceTest.java

@@ -16,6 +16,7 @@
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.*;
 
 /**
@@ -229,6 +230,45 @@ void getRecentActiveCommentsByInnovationId_Success() {
         verify(commentRepository, times(1)).findRecentActiveCommentsByInnovationId(testInnovationId);
     }
 
+    @Test
+    void getAllComments_NoLimit_ReturnsAll() {
+        // Arrange
+        List<InnovationCatalogComment> expectedComments = Arrays.asList(testCommentEntity);
+        when(commentRepository.findAllCommentsOrderByActiveSinceDesc(isNull())).thenReturn(expectedComments);
+        
+        // Act
+        List<InnovationCatalogComment> result = commentService.getAllComments(null);
+        
+        // Assert
+        assertNotNull(result);
+        assertEquals(1, result.size());
+        verify(commentRepository, times(1)).findAllCommentsOrderByActiveSinceDesc(isNull());
+    }
+    
+    @Test
+    void getAllComments_WithLimit_ReturnsLimited() {
+        // Arrange
+        List<InnovationCatalogComment> expectedComments = Arrays.asList(testCommentEntity);
+        when(commentRepository.findAllCommentsOrderByActiveSinceDesc(5)).thenReturn(expectedComments);
+        
+        // Act
+        List<InnovationCatalogComment> result = commentService.getAllComments(5);
+        
+        // Assert
+        assertNotNull(result);
+        verify(commentRepository, times(1)).findAllCommentsOrderByActiveSinceDesc(5);
+    }
+    
+    @Test
+    void getAllComments_InvalidLimit_ThrowsException() {
+        // Act & Assert
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+                () -> commentService.getAllComments(0));
+        
+        assertEquals("Limit must be greater than zero", exception.getMessage());
+        verify(commentRepository, never()).findAllCommentsOrderByActiveSinceDesc(any());
+    }
+    
     @Test
     void deactivateComment_Success() {
         // Arrange
@@ -308,4 +348,4 @@ void isCommentActive_NullCommentId_ReturnsFalse() {
         assertFalse(result);
         verify(commentRepository, never()).existsActiveComment(any());
     }
-}
+}