HDPI-4238 - Added new description column in Document table

src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/AdditionalDocument.java

@@ -28,7 +28,8 @@ public class AdditionalDocument {
 
     @CCD(label = "Short description",
         typeOverride = FieldType.TextArea,
-        access = {CitizenAccess.class}
+        access = {CitizenAccess.class},
+        max = 60
     )
     private String description;
 }

src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/DocumentEntity.java

@@ -54,6 +54,8 @@ public class DocumentEntity {
     @Enumerated(EnumType.STRING)
     private DocumentType type;
 
+    private String description;
+
     @OneToMany(fetch = LAZY, cascade = ALL, mappedBy = "document")
     @Builder.Default
     @JsonManagedReference

src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/DocumentService.java

@@ -1,8 +1,11 @@
 package uk.gov.hmcts.reform.pcs.ccd.service;
 
 import lombok.AllArgsConstructor;
-import org.apache.commons.lang3.tuple.Pair;
+import lombok.Builder;
+import lombok.Data;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
 import uk.gov.hmcts.ccd.sdk.type.Document;
 import uk.gov.hmcts.ccd.sdk.type.ListValue;
 import uk.gov.hmcts.reform.pcs.ccd.domain.AdditionalDocument;
@@ -31,8 +34,7 @@ public class DocumentService {
 
     public List<DocumentEntity> createAllDocuments(PCSCase pcsCase) {
 
-        List<Pair<Document, DocumentType>> allDocuments = new ArrayList<>();
-
+        List<DocumentHolder> allDocuments = new ArrayList<>();
         allDocuments.addAll(mapAdditionalDocumentsWithType(pcsCase.getAdditionalDocuments()));
 
         allDocuments.addAll(mapDocumentsWithType(
@@ -58,49 +60,55 @@ public List<DocumentEntity> createAllDocuments(PCSCase pcsCase) {
         return documentRepository.saveAll(createDocumentEntities(allDocuments));
     }
 
-    private List<Pair<Document, DocumentType>> mapDocumentsWithType(
+    private List<DocumentHolder> mapDocumentsWithType(
         List<ListValue<Document>> docs, DocumentType type) {
 
-        if (docs == null || docs.isEmpty()) {
+        if (CollectionUtils.isEmpty(docs)) {
             return Collections.emptyList();
         }
 
         return docs.stream()
             .map(ListValue::getValue)
             .filter(Objects::nonNull)
-            .map(doc -> Pair.of(doc, type))
+            .map(doc -> DocumentHolder.builder()
+                    .document(doc)
+                    .type(type)
+                    .description("")
+                    .build())
             .toList();
     }
 
-    private List<Pair<Document, DocumentType>> mapAdditionalDocumentsWithType(
+    private List<DocumentHolder> mapAdditionalDocumentsWithType(
         List<ListValue<AdditionalDocument>> documents) {
 
-        if (documents == null || documents.isEmpty()) {
+        if (CollectionUtils.isEmpty(documents)) {
             return Collections.emptyList();
         }
 
         return ListValueUtils.unwrapListItems(documents).stream()
-            .map(doc -> Pair.of(
-                doc.getDocument(),
-                mapAdditionalDocumentTypeToDocumentType(doc.getDocumentType())
-            ))
+            .map(doc -> DocumentHolder.builder()
+                    .document(doc.getDocument())
+                    .type(mapAdditionalDocumentTypeToDocumentType(doc.getDocumentType()))
+                    .description(doc.getDescription())
+                    .build())
             .toList();
     }
 
     private List<DocumentEntity> createDocumentEntities(
-        List<Pair<Document, DocumentType>> documents) {
+        List<DocumentHolder> documents) {
 
-        if (documents == null || documents.isEmpty()) {
+        if (CollectionUtils.isEmpty(documents)) {
             return List.of();
         }
 
         return documents.stream()
-            .map(pair -> DocumentEntity.builder()
-                .url(pair.getKey().getUrl())
-                .fileName(pair.getKey().getFilename())
-                .binaryUrl(pair.getKey().getBinaryUrl())
-                .categoryId(pair.getKey().getCategoryId())
-                .type(pair.getValue())
+            .map(holder -> DocumentEntity.builder()
+                .url(holder.getDocument().getUrl())
+                .fileName(holder.getDocument().getFilename())
+                .binaryUrl(holder.getDocument().getBinaryUrl())
+                .categoryId(holder.getDocument().getCategoryId())
+                .type(holder.getType())
+                .description(StringUtils.isEmpty(holder.getDescription()) ? null : holder.getDescription())
                 .build())
             .toList();
     }
@@ -122,4 +130,12 @@ private DocumentType mapAdditionalDocumentTypeToDocumentType(AdditionalDocumentT
             case OTHER -> DocumentType.OTHER;
         };
     }
+
+    @Builder
+    @Data
+    private static class DocumentHolder {
+        private Document document;
+        private DocumentType type;
+        private String description;
+    }
 }

src/main/resources/db/migration/V075__add_description_to_Document_table.sql

@@ -0,0 +1 @@
+ALTER TABLE Document ADD COLUMN description VARCHAR(60);

src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/DocumentServiceTest.java

@@ -260,4 +260,66 @@ void shouldReturnEmptyListIfNoDocuments() {
         assertThat(entities).isEmpty();
         verify(documentRepository).saveAll(anyList());
     }
+
+    @Test
+    void shouldSaveDescriptionForAdditionalDocuments() {
+        // Given
+        PCSCase pcsCase = mock(PCSCase.class);
+
+        AdditionalDocumentType additionalDocumentType =  AdditionalDocumentType.WITNESS_STATEMENT;
+        String description = "A short description";
+
+        AdditionalDocument additionalDocument1 = AdditionalDocument.builder()
+                .document(Document.builder().build())
+                .documentType(additionalDocumentType)
+                .description(description)
+                .build();
+
+        List<ListValue<AdditionalDocument>> additionalDocuments = List.of(
+                ListValue.<AdditionalDocument>builder().value(additionalDocument1).build()
+        );
+
+        when(pcsCase.getAdditionalDocuments()).thenReturn(additionalDocuments);
+
+        // When
+        underTest.createAllDocuments(pcsCase);
+
+        // Then
+        DocumentType expectedDocumentType = DocumentType.valueOf(additionalDocumentType.name());
+
+        verify(documentRepository).saveAll(documentEntityListCaptor.capture());
+        List<DocumentEntity> capturedEntities = documentEntityListCaptor.getValue();
+
+        assertThat(capturedEntities)
+                .extracting(DocumentEntity::getType)
+                .containsExactly(expectedDocumentType);
+
+        assertThat(capturedEntities)
+                .extracting(DocumentEntity::getDescription)
+                .containsExactly(description);
+    }
+
+    @Test
+    void shouldAllowNullDescriptionForDocumentsOtherThanAdditionalDocuments() {
+        // Given
+        PCSCase pcsCase = mock(PCSCase.class);
+
+        Document doc = Document.builder()
+                .build();
+
+        NoticeServedDetails noticeServedDetails = NoticeServedDetails.builder()
+                .noticeDocuments(List.of(ListValue.<Document>builder().id("1").value(doc).build()))
+                .build();
+
+        when(pcsCase.getNoticeServedDetails()).thenReturn(noticeServedDetails);
+
+        // When
+        underTest.createAllDocuments(pcsCase);
+
+        // Then
+        verify(documentRepository).saveAll(documentEntityListCaptor.capture());
+        List<DocumentEntity> entities = documentEntityListCaptor.getValue();
+        DocumentEntity entity = entities.getFirst();
+        assertThat(entity.getDescription()).isNull();
+    }
 }