Dfr 3543 ct judiciary upload multiple attachments function

src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderAboutToSubmitHandler.java

@@ -0,0 +1,96 @@
+package uk.gov.hmcts.reform.finrem.caseorchestration.handler;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.springframework.stereotype.Service;
+import uk.gov.hmcts.reform.ccd.client.model.CaseDetails;
+import uk.gov.hmcts.reform.finrem.caseorchestration.ccd.callback.CallbackType;
+import uk.gov.hmcts.reform.finrem.caseorchestration.controllers.GenericAboutToStartOrSubmitCallbackResponse;
+import uk.gov.hmcts.reform.finrem.caseorchestration.mapper.FinremCaseDetailsMapper;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.EventType;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.CaseDocument;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.CaseType;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.DraftDirectionOrderCollection;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.FinremCaseData;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.FinremCaseDetails;
+import uk.gov.hmcts.reform.finrem.caseorchestration.service.CaseDataService;
+import uk.gov.hmcts.reform.finrem.caseorchestration.service.ContestedOrderApprovedLetterService;
+import uk.gov.hmcts.reform.finrem.caseorchestration.service.GenericDocumentService;
+import uk.gov.hmcts.reform.finrem.caseorchestration.service.HearingOrderService;
+import uk.gov.hmcts.reform.finrem.caseorchestration.service.documentcatergory.UploadedDraftOrderCategoriser;
+
+import java.util.List;
+import java.util.Map;
+
+import static uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.CCDConfigConstant.DRAFT_DIRECTION_DETAILS_COLLECTION;
+import static uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.CCDConfigConstant.DRAFT_DIRECTION_DETAILS_COLLECTION_RO;
+
+@Slf4j
+@Service
+public class JudgeDraftOrderAboutToSubmitHandler extends FinremCallbackHandler {
+
+    private final HearingOrderService hearingOrderService;
+    private final GenericDocumentService genericDocumentService;
+    private final ContestedOrderApprovedLetterService contestedOrderApprovedLetterService;
+    private final CaseDataService caseDataService;
+    private final UploadedDraftOrderCategoriser uploadedDraftOrderCategoriser;
+
+    public JudgeDraftOrderAboutToSubmitHandler(FinremCaseDetailsMapper finremCaseDetailsMapper, HearingOrderService hearingOrderService,
+                                               GenericDocumentService genericDocumentService,
+                                               ContestedOrderApprovedLetterService contestedOrderApprovedLetterService,
+                                               CaseDataService caseDataService,
+                                               UploadedDraftOrderCategoriser uploadedDraftOrderCategoriser) {
+        super(finremCaseDetailsMapper);
+        this.hearingOrderService = hearingOrderService;
+        this.genericDocumentService = genericDocumentService;
+        this.contestedOrderApprovedLetterService = contestedOrderApprovedLetterService;
+        this.caseDataService = caseDataService;
+        this.uploadedDraftOrderCategoriser = uploadedDraftOrderCategoriser;
+    }
+
+    @Override
+    public boolean canHandle(CallbackType callbackType, CaseType caseType, EventType eventType) {
+        return CallbackType.ABOUT_TO_SUBMIT.equals(callbackType)
+            && CaseType.CONTESTED.equals(caseType)
+            && (EventType.JUDGE_DRAFT_ORDER.equals(eventType));
+    }
+
+    @Override
+    public GenericAboutToStartOrSubmitCallbackResponse<FinremCaseData> handle(FinremCallbackRequest callbackRequest,
+                                                                              String userAuthorisation) {
+
+        FinremCaseDetails finremCaseDetails = callbackRequest.getCaseDetails();
+        String caseId = String.valueOf(finremCaseDetails.getId());
+        log.info("Invoking contested event {} mid callback for Case ID: {}",
+            EventType.JUDGE_DRAFT_ORDER, caseId);
+        validateCaseData(callbackRequest);
+
+        CaseDetails caseDetails = finremCaseDetailsMapper.mapToCaseDetails(finremCaseDetails);
+
+        hearingOrderService.convertToPdfAndStampAndStoreLatestDraftHearingOrder(caseDetails, userAuthorisation);
+        convertAdditionalDocumentsToPdf(finremCaseDetails, userAuthorisation);
+        contestedOrderApprovedLetterService.generateAndStoreContestedOrderApprovedLetter(caseDetails, userAuthorisation);
+
+        Map<String, Object> caseData = caseDetails.getData();
+        caseDataService.moveCollection(caseData, DRAFT_DIRECTION_DETAILS_COLLECTION, DRAFT_DIRECTION_DETAILS_COLLECTION_RO);
+
+        uploadedDraftOrderCategoriser.categorise(finremCaseDetails.getData());
+
+        return GenericAboutToStartOrSubmitCallbackResponse.<FinremCaseData>builder()
+            .data(finremCaseDetails.getData()).build();
+    }
+
+    private void convertAdditionalDocumentsToPdf(FinremCaseDetails caseDetails, String authorisation) {
+        FinremCaseData caseData = caseDetails.getData();
+        List<DraftDirectionOrderCollection> directionOrderCollection = caseData.getDraftDirectionWrapper().getDraftDirectionOrderCollection();
+
+        directionOrderCollection.stream().map(order -> order.getValue().getJudgeApprovedOrderAdditionalDocumentsCollection())
+            .filter(CollectionUtils::isNotEmpty).forEach(additionalDocs -> additionalDocs.forEach(additionalDoc -> {
+                CaseDocument documentPdf = genericDocumentService.convertDocumentIfNotPdfAlready(
+                    additionalDoc.getValue(), authorisation,
+                    String.valueOf(caseDetails.getId()));
+
+                additionalDoc.setValue(documentPdf);
+            }));
+    }
+}

src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/model/ccd/DraftDirectionOrder.java

@@ -8,6 +8,8 @@
 import lombok.EqualsAndHashCode;
 import lombok.NoArgsConstructor;
 
+import java.util.List;
+
 @JsonIgnoreProperties(ignoreUnknown = true)
 @Data
 @Builder
@@ -21,4 +23,7 @@ public class DraftDirectionOrder implements HasCaseDocument {
 
     @JsonProperty("uploadDraftDocument")
     CaseDocument uploadDraftDocument;
+
+    @JsonProperty("additionalDocuments")
+    private List<JudgeApprovedOrderAdditionalDocumentsCollection> judgeApprovedOrderAdditionalDocumentsCollection;
 }

src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/model/ccd/JudgeApprovedOrderAdditionalDocumentsCollection.java

@@ -0,0 +1,16 @@
+package uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class JudgeApprovedOrderAdditionalDocumentsCollection {
+    private CaseDocument value;
+}

src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/documentcatergory/UploadedDraftOrderCategoriser.java

@@ -31,6 +31,11 @@ private void categoriseOrders(List<DraftDirectionOrderCollection> orderCollectio
     private void setCategoryIfAbsent(DraftDirectionOrder order, DocumentCategory category) {
         if (order != null && order.getUploadDraftDocument() != null && order.getUploadDraftDocument().getCategoryId() == null) {
             order.getUploadDraftDocument().setCategoryId(category.getDocumentCategoryId());
+
+            Optional.ofNullable(order.getJudgeApprovedOrderAdditionalDocumentsCollection())
+                .ifPresent(additionalDocuments -> additionalDocuments.forEach(document ->
+                    document.getValue().setCategoryId(category.getDocumentCategoryId())
+                ));
         }
     }
 }

src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderAboutToSubmitHandlerTest.java

@@ -0,0 +1,165 @@
+package uk.gov.hmcts.reform.finrem.caseorchestration.handler;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import uk.gov.hmcts.reform.ccd.client.model.CaseDetails;
+import uk.gov.hmcts.reform.finrem.caseorchestration.ccd.callback.CallbackType;
+import uk.gov.hmcts.reform.finrem.caseorchestration.controllers.GenericAboutToStartOrSubmitCallbackResponse;
+import uk.gov.hmcts.reform.finrem.caseorchestration.mapper.FinremCaseDetailsMapper;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.EventType;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.CaseDocument;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.CaseType;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.DraftDirectionOrder;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.DraftDirectionOrderCollection;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.FinremCaseData;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.FinremCaseDetails;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.JudgeApprovedOrderAdditionalDocumentsCollection;
+import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.wrapper.DraftDirectionWrapper;
+import uk.gov.hmcts.reform.finrem.caseorchestration.service.CaseDataService;
+import uk.gov.hmcts.reform.finrem.caseorchestration.service.ContestedOrderApprovedLetterService;
+import uk.gov.hmcts.reform.finrem.caseorchestration.service.GenericDocumentService;
+import uk.gov.hmcts.reform.finrem.caseorchestration.service.HearingOrderService;
+import uk.gov.hmcts.reform.finrem.caseorchestration.service.documentcatergory.UploadedDraftOrderCategoriser;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+import static uk.gov.hmcts.reform.finrem.caseorchestration.TestConstants.AUTH_TOKEN;
+import static uk.gov.hmcts.reform.finrem.caseorchestration.TestSetUpUtils.caseDocument;
+import static uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.CCDConfigConstant.DRAFT_DIRECTION_DETAILS_COLLECTION;
+import static uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.CCDConfigConstant.DRAFT_DIRECTION_DETAILS_COLLECTION_RO;
+import static uk.gov.hmcts.reform.finrem.caseorchestration.test.Assertions.assertCanHandle;
+
+@ExtendWith(MockitoExtension.class)
+class JudgeDraftOrderAboutToSubmitHandlerTest extends BaseHandlerTestSetup {
+
+    private static final String FILE_URL = "http://dm:80/documents/kbjh87y8y9JHVKKKJVJ";
+    private static final String FILE_BINARY_URL = "http://dm:80/documents/kbjh87y8y9JHVKKKJVJ/binary";
+    private static final String FILE_NAME = "abc.pdf";
+
+    @Mock
+    private JudgeDraftOrderAboutToSubmitHandler handler;
+    @Mock
+    private HearingOrderService hearingOrderService;
+    @Mock
+    private GenericDocumentService genericDocumentService;
+    @Mock
+    private ContestedOrderApprovedLetterService contestedOrderApprovedLetterService;
+    @Mock
+    private CaseDataService caseDataService;
+    @Mock
+    private UploadedDraftOrderCategoriser uploadedDraftOrderCategoriser;
+    @Mock
+    private FinremCaseDetailsMapper finremCaseDetailsMapper;
+
+    @BeforeEach
+    void setUp() {
+        handler = new JudgeDraftOrderAboutToSubmitHandler(
+            finremCaseDetailsMapper,
+            hearingOrderService,
+            genericDocumentService,
+            contestedOrderApprovedLetterService,
+            caseDataService,
+            uploadedDraftOrderCategoriser
+        );
+    }
+
+    @Test
+    void canHandle() {
+        assertCanHandle(handler, CallbackType.ABOUT_TO_SUBMIT, CaseType.CONTESTED, EventType.JUDGE_DRAFT_ORDER);
+    }
+
+    @Test
+    void givenNoAdditionalDocuments_whenHandle_thenAllInvocationsAreExecuted() {
+        CaseDetails caseDetails = CaseDetails.builder().build();
+        //No additional Documents
+        FinremCallbackRequest callbackRequest = setupTestData(Collections.emptyList());
+
+        when(finremCaseDetailsMapper.mapToCaseDetails(any())).thenReturn(caseDetails);
+
+        handler.handle(callbackRequest, AUTH_TOKEN);
+
+        verify(hearingOrderService).convertToPdfAndStampAndStoreLatestDraftHearingOrder(caseDetails, AUTH_TOKEN);
+        verify(caseDataService).moveCollection(caseDetails.getData(), DRAFT_DIRECTION_DETAILS_COLLECTION, DRAFT_DIRECTION_DETAILS_COLLECTION_RO);
+        verify(uploadedDraftOrderCategoriser).categorise(callbackRequest.getCaseDetails().getData());
+        verify(contestedOrderApprovedLetterService).generateAndStoreContestedOrderApprovedLetter(caseDetails, AUTH_TOKEN);
+        verifyNoInteractions(genericDocumentService); // Ensure no unnecessary document conversions
+    }
+
+    @Test
+    void givenMultipleAdditionalDocuments_whenHandle_thenAllAdditionalDocumentsAreConvertedToPdf() {
+        CaseDetails caseDetails = CaseDetails.builder().build();
+        CaseDocument document1 = CaseDocument.builder().documentFilename("additional doc 1.docx").build();
+        CaseDocument document2 = CaseDocument.builder().documentFilename("additional doc 2.docx").build();
+        CaseDocument pdfConverted1 = caseDocument(FILE_URL, "additional doc 1.pdf", FILE_BINARY_URL);
+        CaseDocument pdfConverted2 = caseDocument(FILE_URL, "additional doc 2.pdf", FILE_BINARY_URL);
+
+        when(genericDocumentService.convertDocumentIfNotPdfAlready(eq(document1), eq(AUTH_TOKEN), any(String.class))).thenReturn(pdfConverted1);
+        when(genericDocumentService.convertDocumentIfNotPdfAlready(eq(document2), eq(AUTH_TOKEN), any(String.class))).thenReturn(pdfConverted2);
+        when(finremCaseDetailsMapper.mapToCaseDetails(any())).thenReturn(caseDetails);
+
+        JudgeApprovedOrderAdditionalDocumentsCollection additionalDocument1 = JudgeApprovedOrderAdditionalDocumentsCollection.builder()
+            .value(document1)
+            .build();
+        JudgeApprovedOrderAdditionalDocumentsCollection additionalDocument2 = JudgeApprovedOrderAdditionalDocumentsCollection.builder()
+            .value(document2)
+            .build();
+
+        FinremCallbackRequest callbackRequest = setupTestData(List.of(additionalDocument1, additionalDocument2));
+
+        GenericAboutToStartOrSubmitCallbackResponse<FinremCaseData> response = handler.handle(callbackRequest, AUTH_TOKEN);
+
+        DraftDirectionOrder draftOrderResult = response.getData().getDraftDirectionWrapper().getDraftDirectionOrderCollection().get(0).getValue();
+        assertThat(draftOrderResult.getJudgeApprovedOrderAdditionalDocumentsCollection())
+            .extracting(JudgeApprovedOrderAdditionalDocumentsCollection::getValue)
+            .containsExactlyInAnyOrder(pdfConverted1, pdfConverted2)
+            .hasSize(2);
+
+        verify(genericDocumentService, times(2)).convertDocumentIfNotPdfAlready(any(CaseDocument.class),
+            any(String.class), any(String.class));
+        verify(hearingOrderService).convertToPdfAndStampAndStoreLatestDraftHearingOrder(caseDetails, AUTH_TOKEN);
+        verify(caseDataService).moveCollection(caseDetails.getData(), DRAFT_DIRECTION_DETAILS_COLLECTION, DRAFT_DIRECTION_DETAILS_COLLECTION_RO);
+        verify(uploadedDraftOrderCategoriser).categorise(callbackRequest.getCaseDetails().getData());
+        verify(contestedOrderApprovedLetterService).generateAndStoreContestedOrderApprovedLetter(caseDetails, AUTH_TOKEN);
+    }
+
+    private FinremCallbackRequest setupTestData(List<JudgeApprovedOrderAdditionalDocumentsCollection> additionalDocuments) {
+        CaseDocument caseDocument = caseDocument(FILE_URL, FILE_NAME, FILE_BINARY_URL);
+
+        //Create direction order with additional documents (if any)
+        DraftDirectionOrder directionOrder =
+            DraftDirectionOrder.builder()
+                .purposeOfDocument("test")
+                .uploadDraftDocument(caseDocument)
+                .judgeApprovedOrderAdditionalDocumentsCollection(additionalDocuments)
+                .build();
+
+        DraftDirectionOrderCollection directionOrderCollection = DraftDirectionOrderCollection.builder().value(directionOrder).build();
+
+        //Set up draft direction order collection list
+        List<DraftDirectionOrderCollection> draftDirectionOrderCollection = new ArrayList<>();
+        draftDirectionOrderCollection.add(directionOrderCollection);
+
+        FinremCaseData caseData = FinremCaseData.builder().build();
+        DraftDirectionWrapper draftDirectionWrapper = caseData.getDraftDirectionWrapper();
+        draftDirectionWrapper.setDraftDirectionOrderCollection(draftDirectionOrderCollection);
+
+        FinremCaseDetails finremCaseDetails = FinremCaseDetails.builder().id(123L).data(caseData).build();
+
+        return FinremCallbackRequest.builder()
+            .eventType(EventType.JUDGE_DRAFT_ORDER)
+            .caseDetails(finremCaseDetails)
+            .build();
+    }
+}