diff --git a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/controllers/HearingOrderController.java b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/controllers/HearingOrderController.java index 862d75e10a..1a144aa499 100644 --- a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/controllers/HearingOrderController.java +++ b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/controllers/HearingOrderController.java @@ -71,34 +71,6 @@ public ResponseEntity startHearingOrder( return ResponseEntity.ok(AboutToStartOrSubmitCallbackResponse.builder().data(caseDetails.getData()).build()); } - @PostMapping(path = "/hearing-order/store", consumes = APPLICATION_JSON_VALUE, produces = APPLICATION_JSON_VALUE) - @Operation(summary = "Handles conversion of hearing order if required and storage") - @ApiResponses(value = { - @ApiResponse(responseCode = "200", description = "Callback was processed successfully or in case of an error message is attached to the case", - content = {@Content(mediaType = "application/json", schema = @Schema(implementation = AboutToStartOrSubmitCallbackResponse.class))}), - @ApiResponse(responseCode = "400", description = "Bad Request"), - @ApiResponse(responseCode = "500", description = "Internal Server Error")}) - public ResponseEntity storeHearingOrder( - @RequestHeader(value = AUTHORIZATION_HEADER) String authorisationToken, - @NotNull @RequestBody @Parameter(description = "CaseData") CallbackRequest callback) { - CaseDetails caseDetails = callback.getCaseDetails(); - log.info("Received request to store hearing order for Case ID: {}", caseDetails.getId()); - - validateCaseData(callback); - - Map caseData = caseDetails.getData(); - hearingOrderService.convertToPdfAndStampAndStoreLatestDraftHearingOrder(caseDetails, authorisationToken); - contestedOrderApprovedLetterService.generateAndStoreContestedOrderApprovedLetter(caseDetails, authorisationToken); - caseDataService.moveCollection(caseData, DRAFT_DIRECTION_DETAILS_COLLECTION, DRAFT_DIRECTION_DETAILS_COLLECTION_RO); - - FinremCaseDetails finremCaseDetails = finremCaseDetailsMapper.mapToFinremCaseDetails(caseDetails); - uploadedDraftOrderCategoriser.categorise(finremCaseDetails.getData()); - CaseDetails caseDetailsToReturn = finremCaseDetailsMapper.mapToCaseDetails(finremCaseDetails); - - return ResponseEntity.ok(AboutToStartOrSubmitCallbackResponse.builder().data(caseDetailsToReturn.getData()).build()); - - } - @PostMapping(path = "/hearing-order/approval-start", consumes = APPLICATION_JSON_VALUE, produces = APPLICATION_JSON_VALUE) @Operation(summary = "Starts hearing order approval") @ApiResponses(value = { diff --git a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderAboutToSubmitHandler.java b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderAboutToSubmitHandler.java new file mode 100644 index 0000000000..ef95e6cfa1 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderAboutToSubmitHandler.java @@ -0,0 +1,84 @@ +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.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; + +@Slf4j +@Service +public class JudgeDraftOrderAboutToSubmitHandler extends FinremCallbackHandler { + + private final HearingOrderService hearingOrderService; + private final GenericDocumentService genericDocumentService; + private final ContestedOrderApprovedLetterService contestedOrderApprovedLetterService; + private final UploadedDraftOrderCategoriser uploadedDraftOrderCategoriser; + + public JudgeDraftOrderAboutToSubmitHandler(FinremCaseDetailsMapper finremCaseDetailsMapper, HearingOrderService hearingOrderService, + GenericDocumentService genericDocumentService, + ContestedOrderApprovedLetterService contestedOrderApprovedLetterService, + UploadedDraftOrderCategoriser uploadedDraftOrderCategoriser) { + super(finremCaseDetailsMapper); + this.hearingOrderService = hearingOrderService; + this.genericDocumentService = genericDocumentService; + this.contestedOrderApprovedLetterService = contestedOrderApprovedLetterService; + 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 handle(FinremCallbackRequest callbackRequest, + String userAuthorisation) { + + FinremCaseDetails finremCaseDetails = callbackRequest.getCaseDetails(); + String caseId = String.valueOf(finremCaseDetails.getId()); + log.info("Invoking contested event {} about to submit callback for Case ID: {}", + callbackRequest.getEventType(), caseId); + validateCaseData(callbackRequest); + convertAdditionalDocumentsToPdf(finremCaseDetails, userAuthorisation); + CaseDetails caseDetails = finremCaseDetailsMapper.mapToCaseDetails(finremCaseDetails); + + hearingOrderService.convertToPdfAndStampAndStoreLatestDraftHearingOrder(caseDetails, userAuthorisation); + contestedOrderApprovedLetterService.generateAndStoreContestedOrderApprovedLetter(caseDetails, userAuthorisation); + FinremCaseDetails finremCaseDetailsUpdated = finremCaseDetailsMapper.mapToFinremCaseDetails(caseDetails); + uploadedDraftOrderCategoriser.categorise(finremCaseDetailsUpdated.getData()); + + return GenericAboutToStartOrSubmitCallbackResponse.builder() + .data(finremCaseDetailsUpdated.getData()).build(); + } + + private void convertAdditionalDocumentsToPdf(FinremCaseDetails caseDetails, String authorisation) { + FinremCaseData caseData = caseDetails.getData(); + List directionOrderCollection = caseData.getDraftDirectionWrapper().getDraftDirectionOrderCollection(); + + directionOrderCollection.stream().map(order -> order.getValue().getAdditionalDocuments()) + .filter(CollectionUtils::isNotEmpty).forEach(additionalDocs -> additionalDocs.forEach(additionalDoc -> { + CaseDocument documentPdf = genericDocumentService.convertDocumentIfNotPdfAlready( + additionalDoc.getValue(), authorisation, + String.valueOf(caseDetails.getId())); + + additionalDoc.setValue(documentPdf); + })); + } +} diff --git a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderMidHandler.java b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderMidHandler.java index 85eeb63f06..58c73ec4de 100644 --- a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderMidHandler.java +++ b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderMidHandler.java @@ -1,6 +1,7 @@ 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.finrem.caseorchestration.ccd.callback.CallbackType; import uk.gov.hmcts.reform.finrem.caseorchestration.controllers.GenericAboutToStartOrSubmitCallbackResponse; @@ -22,6 +23,9 @@ public class JudgeDraftOrderMidHandler extends FinremCallbackHandler { private final BulkPrintDocumentService service; + private static final String NO_ORDERS_IN_COLLECTION + = "No orders have been uploaded. Please upload an order."; + public JudgeDraftOrderMidHandler(FinremCaseDetailsMapper finremCaseDetailsMapper, BulkPrintDocumentService service) { super(finremCaseDetailsMapper); @@ -43,10 +47,16 @@ public GenericAboutToStartOrSubmitCallbackResponse handle(Finrem log.info("Invoking contested event {} mid callback for Case ID: {}", EventType.JUDGE_DRAFT_ORDER, caseId); FinremCaseData caseData = caseDetails.getData(); - DraftDirectionWrapper draftDirectionWrapper = caseData.getDraftDirectionWrapper(); List draftDirectionOrderCollection = draftDirectionWrapper.getDraftDirectionOrderCollection(); + List errors = new ArrayList<>(); + if (CollectionUtils.isEmpty(draftDirectionOrderCollection)) { + errors.add(NO_ORDERS_IN_COLLECTION); + return GenericAboutToStartOrSubmitCallbackResponse.builder() + .data(caseData).errors(errors).build(); + } + FinremCaseDetails caseDetailsBefore = callbackRequest.getCaseDetailsBefore(); FinremCaseData beforeCaseData = caseDetailsBefore.getData(); DraftDirectionWrapper draftDirectionWrapperBefore = beforeCaseData.getDraftDirectionWrapper(); @@ -59,7 +69,6 @@ public GenericAboutToStartOrSubmitCallbackResponse handle(Finrem } } - List errors = new ArrayList<>(); draftDirectionOrderCollection.forEach(doc -> service.validateEncryptionOnUploadedDocument(doc.getValue().getUploadDraftDocument(), caseId, errors, userAuthorisation) diff --git a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/model/ccd/DirectionOrder.java b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/model/ccd/DirectionOrder.java index 740f24d613..c13b7bd769 100644 --- a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/model/ccd/DirectionOrder.java +++ b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/model/ccd/DirectionOrder.java @@ -10,6 +10,7 @@ import lombok.NoArgsConstructor; import java.time.LocalDateTime; +import java.util.List; @JsonIgnoreProperties(ignoreUnknown = true) @Data @@ -26,4 +27,6 @@ public class DirectionOrder implements HasCaseDocument { YesOrNo isOrderStamped; @JsonProperty("originalDocument") CaseDocument originalDocument; + @JsonProperty("additionalDocuments") + private List additionalDocuments; } diff --git a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/model/ccd/DraftDirectionOrder.java b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/model/ccd/DraftDirectionOrder.java index 31b4cc4925..a1c7baa88a 100644 --- a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/model/ccd/DraftDirectionOrder.java +++ b/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 additionalDocuments; } diff --git a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/HearingOrderService.java b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/HearingOrderService.java index 431ab32da0..cea3191ae9 100644 --- a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/HearingOrderService.java +++ b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/HearingOrderService.java @@ -12,6 +12,7 @@ import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.CollectionElement; import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.DirectionOrder; import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.DirectionOrderCollection; +import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.DocumentCollection; 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; @@ -52,14 +53,16 @@ public void convertToPdfAndStampAndStoreLatestDraftHearingOrder(CaseDetails case if (judgeApprovedHearingOrder.isPresent()) { String caseId = caseDetails.getId().toString(); + DraftDirectionOrder order = judgeApprovedHearingOrder.get(); CaseDocument latestDraftDirectionOrderDocument = genericDocumentService.convertDocumentIfNotPdfAlready( - judgeApprovedHearingOrder.get().getUploadDraftDocument(), + order.getUploadDraftDocument(), authorisationToken, caseId); CaseDocument stampedHearingOrder = genericDocumentService.stampDocument(latestDraftDirectionOrderDocument, authorisationToken, documentHelper.getStampType(caseDetails.getData()), caseId); updateCaseDataForLatestDraftHearingOrder(caseData, stampedHearingOrder); - updateCaseDataForLatestHearingOrderCollection(caseData, stampedHearingOrder, authorisationToken); - appendDocumentToHearingOrderCollection(caseDetails, stampedHearingOrder); + List additionalDocs = order.getAdditionalDocuments(); + updateCaseDataForLatestHearingOrderCollection(caseData, stampedHearingOrder, authorisationToken, additionalDocs); + appendDocumentToHearingOrderCollection(caseDetails, stampedHearingOrder, additionalDocs); } else { throw new InvalidCaseDataException(BAD_REQUEST.value(), "Missing data from callbackRequest."); } @@ -135,6 +138,7 @@ public Optional draftDirectionOrderCollectionTail(CaseDetai genericDocumentService.convertDocumentIfNotPdfAlready( draftOrder.getUploadDraftDocument(), authorisationToken, caseId)) + .additionalDocuments(draftOrder.getAdditionalDocuments()) .build()); } @@ -152,14 +156,14 @@ private Optional getJudgeApprovedHearingOrder(CaseDetails c : draftDirectionOrderCollectionTail; } - private void appendDocumentToHearingOrderCollection(CaseDetails caseDetails, CaseDocument document) { + private void appendDocumentToHearingOrderCollection(CaseDetails caseDetails, CaseDocument document, List additionalDocs) { Map caseData = caseDetails.getData(); List> directionOrders = Optional.ofNullable(caseData.get(HEARING_ORDER_COLLECTION)) .map(this::convertToListOfDirectionOrder) .orElse(new ArrayList<>()); - DirectionOrder newDirectionOrder = DirectionOrder.builder().uploadDraftDocument(document).build(); + DirectionOrder newDirectionOrder = DirectionOrder.builder().uploadDraftDocument(document).additionalDocuments(additionalDocs).build(); directionOrders.add(CollectionElement.builder().value(newDirectionOrder).build()); caseData.put(HEARING_ORDER_COLLECTION, directionOrders); @@ -171,13 +175,15 @@ private void updateCaseDataForLatestDraftHearingOrder(Map caseDa public void updateCaseDataForLatestHearingOrderCollection(Map caseData, CaseDocument stampedHearingOrder, - String authorisationToken) { + String authorisationToken, + List additionalDocs) { List finalOrderCollection = documentHelper.getFinalOrderCollection(caseData); List finalDatedCollection = orderDateService.addCreatedDateInFinalOrder(finalOrderCollection, authorisationToken); if (!documentHelper.checkIfOrderAlreadyInFinalOrderCollection(finalDatedCollection, stampedHearingOrder)) { DirectionOrderCollection latestOrder = DirectionOrderCollection.builder() .value(DirectionOrder.builder() .uploadDraftDocument(stampedHearingOrder) + .additionalDocuments(additionalDocs) .orderDateTime(LocalDateTime.now()) .isOrderStamped(YesOrNo.YES) .build()) diff --git a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/documentcatergory/UploadedDraftOrderCategoriser.java b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/documentcatergory/UploadedDraftOrderCategoriser.java index aaf63762f5..298d92f297 100644 --- a/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/documentcatergory/UploadedDraftOrderCategoriser.java +++ b/src/main/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/documentcatergory/UploadedDraftOrderCategoriser.java @@ -31,6 +31,11 @@ private void categoriseOrders(List 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.getAdditionalDocuments()) + .ifPresent(additionalDocuments -> additionalDocuments.forEach(document -> + document.getValue().setCategoryId(category.getDocumentCategoryId()) + )); } } } diff --git a/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/controllers/HearingOrderControllerTest.java b/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/controllers/HearingOrderControllerTest.java index 601a0ce47d..c7b0f3dc35 100644 --- a/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/controllers/HearingOrderControllerTest.java +++ b/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/controllers/HearingOrderControllerTest.java @@ -66,18 +66,6 @@ public void setup() { finremCaseDetails = buildFinremCallbackRequest().getCaseDetails(); } - @Test - public void whenStoreHearingOrder_expectedServicesAreInvoked() { - when(finremCaseDetailsMapper.mapToCaseDetails(any())).thenReturn(caseDetails); - when(finremCaseDetailsMapper.mapToFinremCaseDetails(any())).thenReturn(finremCaseDetails); - - hearingOrderController.storeHearingOrder(AUTH_TOKEN, request); - - verify(hearingOrderService).convertToPdfAndStampAndStoreLatestDraftHearingOrder(any(), eq(AUTH_TOKEN)); - verify(caseDataService).moveCollection(any(), eq(DRAFT_DIRECTION_DETAILS_COLLECTION), eq(DRAFT_DIRECTION_DETAILS_COLLECTION_RO)); - verify(uploadedDraftOrderCategoriser).categorise(any()); - } - @Test public void givenDraftDirectionOrderCollectionIsNotEmpty_whenStartingHearingOrderApproval_thenLatestDraftDirOrderIsPopulated() { DraftDirectionOrder draftDirectionOrder = DraftDirectionOrder.builder().build(); diff --git a/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderAboutToSubmitHandlerTest.java b/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderAboutToSubmitHandlerTest.java new file mode 100644 index 0000000000..1140d07be2 --- /dev/null +++ b/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderAboutToSubmitHandlerTest.java @@ -0,0 +1,161 @@ +package uk.gov.hmcts.reform.finrem.caseorchestration.handler; + +import com.fasterxml.jackson.databind.ObjectMapper; +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.Spy; +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.DocumentCollection; +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.State; +import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.wrapper.DraftDirectionWrapper; +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.test.Assertions.assertCanHandle; + +@ExtendWith(MockitoExtension.class) +class JudgeDraftOrderAboutToSubmitHandlerTest { + + 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"; + + private JudgeDraftOrderAboutToSubmitHandler handler; + @Mock + private HearingOrderService hearingOrderService; + @Mock + private GenericDocumentService genericDocumentService; + @Mock + private ContestedOrderApprovedLetterService contestedOrderApprovedLetterService; + + @Mock + private UploadedDraftOrderCategoriser uploadedDraftOrderCategoriser; + @Spy + private ObjectMapper objectMapper; + + @BeforeEach + void setUp() { + FinremCaseDetailsMapper finremCaseDetailsMapper = new FinremCaseDetailsMapper(objectMapper); + handler = new JudgeDraftOrderAboutToSubmitHandler( + finremCaseDetailsMapper, + hearingOrderService, + genericDocumentService, + contestedOrderApprovedLetterService, + uploadedDraftOrderCategoriser + ); + } + + @Test + void canHandle() { + assertCanHandle(handler, CallbackType.ABOUT_TO_SUBMIT, CaseType.CONTESTED, EventType.JUDGE_DRAFT_ORDER); + } + + @Test + void givenNoAdditionalDocuments_whenHandle_thenAllInvocationsAreExecuted() { + //No additional Documents + FinremCallbackRequest callbackRequest = setupTestData(Collections.emptyList()); + + handler.handle(callbackRequest, AUTH_TOKEN); + + verify(hearingOrderService).convertToPdfAndStampAndStoreLatestDraftHearingOrder(any(), eq(AUTH_TOKEN)); + verify(uploadedDraftOrderCategoriser).categorise(any(FinremCaseData.class)); + verify(contestedOrderApprovedLetterService).generateAndStoreContestedOrderApprovedLetter(any(CaseDetails.class), eq(AUTH_TOKEN)); + verifyNoInteractions(genericDocumentService); // Ensure no unnecessary document conversions + } + + @Test + void givenMultipleAdditionalDocuments_whenHandle_thenAllAdditionalDocumentsAreConvertedToPdf() { + 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(document1, AUTH_TOKEN, "123")).thenReturn(pdfConverted1); + when(genericDocumentService.convertDocumentIfNotPdfAlready(document2, AUTH_TOKEN, "123")).thenReturn(pdfConverted2); + + DocumentCollection additionalDocument1 = DocumentCollection.builder() + .value(document1) + .build(); + DocumentCollection additionalDocument2 = DocumentCollection.builder() + .value(document2) + .build(); + + FinremCallbackRequest callbackRequest = setupTestData(List.of(additionalDocument1, additionalDocument2)); + + GenericAboutToStartOrSubmitCallbackResponse response = handler.handle(callbackRequest, AUTH_TOKEN); + + assertThat(response.getData().getDraftDirectionWrapper().getDraftDirectionOrderCollection()) + .isNotEmpty() + .extracting(DraftDirectionOrderCollection::getValue) + .flatExtracting(DraftDirectionOrder::getAdditionalDocuments) + .extracting(DocumentCollection::getValue) + .containsExactlyInAnyOrder(pdfConverted1, pdfConverted2); + + verify(genericDocumentService, times(2)).convertDocumentIfNotPdfAlready(any(CaseDocument.class), + any(String.class), any(String.class)); + verify(hearingOrderService).convertToPdfAndStampAndStoreLatestDraftHearingOrder(any(), eq(AUTH_TOKEN)); + verify(uploadedDraftOrderCategoriser).categorise(any(FinremCaseData.class)); + verify(contestedOrderApprovedLetterService).generateAndStoreContestedOrderApprovedLetter(any(CaseDetails.class), eq(AUTH_TOKEN)); + } + + private FinremCallbackRequest setupTestData(List 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) + .additionalDocuments(additionalDocuments) + .build(); + + DraftDirectionOrderCollection directionOrderCollection = DraftDirectionOrderCollection.builder().value(directionOrder).build(); + + //Set up draft direction order collection list + List draftDirectionOrderCollection = new ArrayList<>(); + draftDirectionOrderCollection.add(directionOrderCollection); + + FinremCaseData caseData = FinremCaseData.builder().build(); + DraftDirectionWrapper draftDirectionWrapper = caseData.getDraftDirectionWrapper(); + draftDirectionWrapper.setDraftDirectionOrderCollection(draftDirectionOrderCollection); + + FinremCaseDetails finremCaseDetails = FinremCaseDetails.builder() + .id(123L) + .caseType(CaseType.CONTESTED) + .state(State.SCHEDULING_AND_HEARING) + .data(caseData).build(); + + return FinremCallbackRequest.builder() + .eventType(EventType.JUDGE_DRAFT_ORDER) + .caseDetails(finremCaseDetails) + .build(); + } +} diff --git a/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderMidHandlerTest.java b/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderMidHandlerTest.java index d68c9006c3..13529963ee 100644 --- a/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderMidHandlerTest.java +++ b/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/handler/JudgeDraftOrderMidHandlerTest.java @@ -22,6 +22,7 @@ import java.util.ArrayList; import java.util.List; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; @@ -67,9 +68,18 @@ void canNotHandleWrongCallbackType() { assertFalse(handler.canHandle(CallbackType.ABOUT_TO_START, CaseType.CONTESTED, EventType.JUDGE_DRAFT_ORDER)); } + @Test + void givenDraftDirectionOrderCollectionIsEmpty_whenHandle_shouldGetError() { + FinremCallbackRequest finremCallbackRequest = buildCallbackRequest(EventType.JUDGE_DRAFT_ORDER); + + GenericAboutToStartOrSubmitCallbackResponse response = handler.handle(finremCallbackRequest, AUTH_TOKEN); + + String errorMessage = "No orders have been uploaded. Please upload an order."; + assertThat(response.getErrors()).contains(errorMessage); + } @Test - void givenContestedCase_whenDraftOrderUploadedButNonEncryptedFileShouldNotGetError() throws Exception { + void givenContestedCase_whenDraftOrderUploadedButNonEncryptedFileShouldNotGetError() { FinremCallbackRequest finremCallbackRequest = buildCallbackRequest(EventType.JUDGE_DRAFT_ORDER); FinremCaseData caseData = finremCallbackRequest.getCaseDetails().getData(); @@ -83,7 +93,7 @@ void givenContestedCase_whenDraftOrderUploadedButNonEncryptedFileShouldNotGetErr } @Test - void givenContestedCase_whenThereIsexistingDraftOrderNonEncryptedFileShouldNotGetError() throws Exception { + void givenContestedCase_whenThereIsexistingDraftOrderNonEncryptedFileShouldNotGetError() { FinremCallbackRequest finremCallbackRequest = buildCallbackRequest(EventType.JUDGE_DRAFT_ORDER); FinremCaseData caseData = finremCallbackRequest.getCaseDetails().getData(); diff --git a/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/documentcatergory/UploadedDraftOrderCategoriserTest.java b/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/documentcatergory/UploadedDraftOrderCategoriserTest.java new file mode 100644 index 0000000000..92892e0bf0 --- /dev/null +++ b/src/test/java/uk/gov/hmcts/reform/finrem/caseorchestration/service/documentcatergory/UploadedDraftOrderCategoriserTest.java @@ -0,0 +1,153 @@ +package uk.gov.hmcts.reform.finrem.caseorchestration.service.documentcatergory; + +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.finrem.caseorchestration.model.ccd.CaseDocument; +import uk.gov.hmcts.reform.finrem.caseorchestration.model.ccd.DocumentCollection; +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.wrapper.DraftDirectionWrapper; +import uk.gov.hmcts.reform.finrem.caseorchestration.model.document.DocumentCategory; +import uk.gov.hmcts.reform.finrem.caseorchestration.service.FeatureToggleService; + +import java.util.List; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +class UploadedDraftOrderCategoriserTest { + private UploadedDraftOrderCategoriser uploadedDraftOrderCategoriser; + + @Mock + FeatureToggleService featureToggleService; + + @BeforeEach + public void setUp() { + uploadedDraftOrderCategoriser = new UploadedDraftOrderCategoriser(featureToggleService); + when(featureToggleService.isCaseFileViewEnabled()).thenReturn(true); + } + + @Test + void shouldCategoriseJudgesAmendedOrderCollectionWithoutAdditionalDocuments() { + FinremCaseData caseData = createCaseDataWithJudgeOrders(false); + + uploadedDraftOrderCategoriser.categorise(caseData); + + caseData.getDraftDirectionWrapper().getJudgesAmendedOrderCollection() + .forEach(order -> { + assertEquals(DocumentCategory.SYSTEM_DUPLICATES.getDocumentCategoryId(), order.getValue().getUploadDraftDocument().getCategoryId()); + }); + } + + @Test + void shouldCategoriseDraftDirectionOrderCollectionWithoutAdditionalDocuments() { + FinremCaseData caseData = createCaseDataForDraftDirectionOrderCollection(false); + + uploadedDraftOrderCategoriser.categorise(caseData); + + caseData.getDraftDirectionWrapper().getDraftDirectionOrderCollection() + .forEach(order -> { + assertEquals(DocumentCategory.POST_HEARING_DRAFT_ORDER.getDocumentCategoryId(), + order.getValue().getUploadDraftDocument().getCategoryId()); + }); + } + + @Test + void shouldCategoriseJudgesAmendedOrderCollectionWithAdditionalDocuments() { + FinremCaseData caseData = createCaseDataWithJudgeOrders(true); + + uploadedDraftOrderCategoriser.categorise(caseData); + + caseData.getDraftDirectionWrapper().getJudgesAmendedOrderCollection() + .forEach(order -> { + assertEquals(DocumentCategory.SYSTEM_DUPLICATES.getDocumentCategoryId(), + order.getValue().getUploadDraftDocument().getCategoryId()); + order.getValue().getAdditionalDocuments().forEach(additionalDoc -> + assertEquals(DocumentCategory.SYSTEM_DUPLICATES.getDocumentCategoryId(), additionalDoc.getValue().getCategoryId()) + ); + }); + } + + @Test + void shouldCategoriseDraftDirectionOrderCollectionWithAdditionalDocuments() { + FinremCaseData caseData = createCaseDataForDraftDirectionOrderCollection(true); + + uploadedDraftOrderCategoriser.categorise(caseData); + + caseData.getDraftDirectionWrapper().getDraftDirectionOrderCollection() + .forEach(order -> { + assertEquals(DocumentCategory.POST_HEARING_DRAFT_ORDER.getDocumentCategoryId(), + order.getValue().getUploadDraftDocument().getCategoryId()); + order.getValue().getAdditionalDocuments().forEach(additionalDoc -> + assertEquals(DocumentCategory.POST_HEARING_DRAFT_ORDER.getDocumentCategoryId(), + additionalDoc.getValue().getCategoryId()) + ); + }); + } + + private FinremCaseData createCaseDataWithJudgeOrders(boolean withAdditionalDocuments) { + FinremCaseData caseData = new FinremCaseData(); + DraftDirectionWrapper wrapper = new DraftDirectionWrapper(); + + DraftDirectionOrder order1 = createDraftOrder(withAdditionalDocuments); + + wrapper.setJudgesAmendedOrderCollection(List.of( + createOrderCollection(order1) + )); + + caseData.setDraftDirectionWrapper(wrapper); + return caseData; + } + + + private FinremCaseData createCaseDataForDraftDirectionOrderCollection(boolean withAdditionalDocuments) { + FinremCaseData caseData = new FinremCaseData(); + DraftDirectionWrapper wrapper = new DraftDirectionWrapper(); + + DraftDirectionOrder order1 = createDraftOrder(withAdditionalDocuments); + DraftDirectionOrder order2 = createDraftOrder(withAdditionalDocuments); + + wrapper.setDraftDirectionOrderCollection(List.of( + createOrderCollection(order1), + createOrderCollection(order2) + )); + + caseData.setDraftDirectionWrapper(wrapper); + return caseData; + } + + private DraftDirectionOrderCollection createOrderCollection(DraftDirectionOrder order) { + DraftDirectionOrderCollection collection = new DraftDirectionOrderCollection(); + collection.setValue(order); + return collection; + } + + private DraftDirectionOrder createDraftOrder(boolean withAdditionalDocuments) { + DraftDirectionOrder order = new DraftDirectionOrder(); + CaseDocument draftOrderDocument = CaseDocument.builder().documentFilename("draft order.pdf").build(); + draftOrderDocument.setCategoryId(null); // Simulate missing category + order.setUploadDraftDocument(draftOrderDocument); + + if (withAdditionalDocuments) { + CaseDocument document1 = CaseDocument.builder().documentFilename("additional doc 1.pdf").build(); + CaseDocument document2 = CaseDocument.builder().documentFilename("additional doc 2.pdf").build(); + + DocumentCollection additionalDocument1 = DocumentCollection.builder() + .value(document1) + .build(); + DocumentCollection additionalDocument2 = DocumentCollection.builder() + .value(document2) + .build(); + + order.setAdditionalDocuments(List.of(additionalDocument1, additionalDocument2)); + } else { + order.setAdditionalDocuments(null); + } + return order; + } +}