> getListOrNull() {
return list -> list.isEmpty() ? null : list;
}
diff --git a/progression-command/progression-command-handler/src/raml/json/schema/progression.command.initiate-court-proceedings-for-application.json b/progression-command/progression-command-handler/src/raml/json/schema/progression.command.initiate-court-proceedings-for-application.json
index b5f025db7..72e73a1f0 100644
--- a/progression-command/progression-command-handler/src/raml/json/schema/progression.command.initiate-court-proceedings-for-application.json
+++ b/progression-command/progression-command-handler/src/raml/json/schema/progression.command.initiate-court-proceedings-for-application.json
@@ -20,6 +20,9 @@
"description": "Indicates that the summons approval process is required to be initiated",
"type": "boolean"
},
+ "applicationSource": {
+ "$ref": "http://moj.gov.uk/cpp/progression/enum-def.json#/definitions/applicationSource"
+ },
"isAmended": {
"type": "boolean"
},
diff --git a/progression-command/progression-command-handler/src/test/java/uk/gov/moj/cpp/progression/handler/CourtApplicationHandlerMHSourceTest.java b/progression-command/progression-command-handler/src/test/java/uk/gov/moj/cpp/progression/handler/CourtApplicationHandlerMHSourceTest.java
new file mode 100644
index 000000000..df7a89de7
--- /dev/null
+++ b/progression-command/progression-command-handler/src/test/java/uk/gov/moj/cpp/progression/handler/CourtApplicationHandlerMHSourceTest.java
@@ -0,0 +1,691 @@
+package uk.gov.moj.cpp.progression.handler;
+
+import static com.jayway.jsonpath.matchers.JsonPathMatchers.hasNoJsonPath;
+import static com.jayway.jsonpath.matchers.JsonPathMatchers.withJsonPath;
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static java.util.UUID.randomUUID;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.is;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+import static uk.gov.justice.core.courts.CourtApplication.courtApplication;
+import static uk.gov.justice.core.courts.CourtApplicationCase.courtApplicationCase;
+import static uk.gov.justice.core.courts.CourtApplicationType.courtApplicationType;
+import static uk.gov.justice.core.courts.InitiateCourtApplicationProceedings.initiateCourtApplicationProceedings;
+import static uk.gov.justice.core.courts.Offence.offence;
+import static uk.gov.justice.core.courts.ProsecutionCaseIdentifier.prosecutionCaseIdentifier;
+import static uk.gov.justice.core.courts.SummonsTemplateType.NOT_APPLICABLE;
+import static uk.gov.justice.services.messaging.Envelope.envelopeFrom;
+import static uk.gov.justice.services.test.utils.core.helper.EventStreamMockHelper.verifyAppendAndGetArgumentFrom;
+import static uk.gov.justice.services.test.utils.core.matchers.JsonEnvelopeMatcher.jsonEnvelope;
+import static uk.gov.justice.services.test.utils.core.matchers.JsonEnvelopeMetadataMatcher.metadata;
+import static uk.gov.justice.services.test.utils.core.matchers.JsonEnvelopePayloadMatcher.payload;
+import static uk.gov.justice.services.test.utils.core.matchers.JsonEnvelopeStreamMatcher.streamContaining;
+import static uk.gov.justice.services.test.utils.core.random.RandomGenerator.STRING;
+import static uk.gov.moj.cpp.progression.enums.ApplicationSource.CAAG;
+import static uk.gov.moj.cpp.progression.enums.ApplicationSource.HOME;
+import static uk.gov.moj.cpp.progression.enums.ApplicationSource.MH;
+import static uk.gov.moj.cpp.progression.enums.ApplicationSource.UNKNOWN;
+
+import uk.gov.justice.core.courts.Address;
+import uk.gov.justice.core.courts.ApplicationReferredToBoxwork;
+import uk.gov.justice.core.courts.ApplicationReferredToCourtHearing;
+import uk.gov.justice.core.courts.ApplicationReferredToExistingHearing;
+import uk.gov.justice.core.courts.BoxHearingRequest;
+import uk.gov.justice.core.courts.CourtApplicationAddedToCase;
+import uk.gov.justice.core.courts.CourtApplicationCreated;
+import uk.gov.justice.core.courts.CourtApplicationParty;
+import uk.gov.justice.core.courts.CourtApplicationProceedingsEdited;
+import uk.gov.justice.core.courts.CourtApplicationProceedingsInitiateIgnored;
+import uk.gov.justice.core.courts.CourtApplicationProceedingsInitiated;
+import uk.gov.justice.core.courts.CourtApplicationSummonsApproved;
+import uk.gov.justice.core.courts.CourtApplicationSummonsRejected;
+import uk.gov.justice.core.courts.CourtApplicationUpdated;
+import uk.gov.justice.core.courts.CourtHearingRequest;
+import uk.gov.justice.core.courts.HearingResultedApplicationUpdated;
+import uk.gov.justice.core.courts.HearingUpdatedWithCourtApplication;
+import uk.gov.justice.core.courts.InitiateCourtApplicationProceedings;
+import uk.gov.justice.core.courts.InitiateCourtHearingAfterSummonsApproved;
+import uk.gov.justice.core.courts.MasterDefendant;
+import uk.gov.justice.core.courts.Offence;
+import uk.gov.justice.core.courts.Person;
+import uk.gov.justice.core.courts.PersonDefendant;
+import uk.gov.justice.core.courts.ProsecutingAuthority;
+import uk.gov.justice.core.courts.SendNotificationForApplicationIgnored;
+import uk.gov.justice.core.courts.SendNotificationForApplicationInitiated;
+import uk.gov.justice.core.courts.SendNotificationForAutoApplicationInitiated;
+import uk.gov.justice.progression.courts.HearingPopulatedToProbationCaseworker;
+import uk.gov.justice.progression.courts.VejHearingPopulatedToProbationCaseworker;
+import uk.gov.justice.progression.event.ApplicationHearingDefendantUpdated;
+import uk.gov.justice.services.common.converter.JsonObjectToObjectConverter;
+import uk.gov.justice.services.common.converter.ObjectToJsonObjectConverter;
+import uk.gov.justice.services.common.converter.jackson.ObjectMapperProducer;
+import uk.gov.justice.services.core.aggregate.AggregateService;
+import uk.gov.justice.services.core.enveloper.Enveloper;
+import uk.gov.justice.services.eventsourcing.source.core.EventSource;
+import uk.gov.justice.services.eventsourcing.source.core.EventStream;
+import uk.gov.justice.services.messaging.Envelope;
+import uk.gov.justice.services.messaging.JsonEnvelope;
+import uk.gov.justice.services.messaging.Metadata;
+import uk.gov.justice.services.test.utils.core.enveloper.EnveloperFactory;
+import uk.gov.justice.services.test.utils.framework.api.JsonObjectConvertersFactory;
+import uk.gov.moj.cpp.progression.aggregate.ApplicationAggregate;
+import uk.gov.moj.cpp.progression.service.ApplicationDetailsEnrichmentService;
+import uk.gov.moj.cpp.progression.service.ProsecutionCaseQueryService;
+import uk.gov.moj.cpp.progression.service.RefDataService;
+import uk.gov.moj.cpp.progression.service.service.ProgressionService;
+
+import java.util.UUID;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+/**
+ * Tests for the MH (Manage Hearing) applicationSource fix — AC1 and AC2.
+ *
+ * AC1: MH source + ACTIVE case → offences must be nulled (no CCT-2487 offence selection).
+ * AC2: MH source + INACTIVE/CLOSED case → offences must be preserved (as-is).
+ */
+@ExtendWith(MockitoExtension.class)
+class CourtApplicationHandlerMHSourceTest {
+
+ @Spy
+ private final Enveloper enveloper = EnveloperFactory.createEnveloperWithEvents(
+ CourtApplicationCreated.class,
+ CourtApplicationAddedToCase.class,
+ CourtApplicationProceedingsInitiated.class,
+ ApplicationReferredToBoxwork.class,
+ ApplicationReferredToCourtHearing.class,
+ ApplicationReferredToExistingHearing.class,
+ CourtApplicationProceedingsInitiateIgnored.class,
+ CourtApplicationProceedingsEdited.class,
+ CourtApplicationSummonsRejected.class,
+ CourtApplicationSummonsApproved.class,
+ InitiateCourtHearingAfterSummonsApproved.class,
+ HearingResultedApplicationUpdated.class,
+ HearingUpdatedWithCourtApplication.class,
+ HearingPopulatedToProbationCaseworker.class,
+ VejHearingPopulatedToProbationCaseworker.class,
+ SendNotificationForApplicationInitiated.class,
+ SendNotificationForApplicationIgnored.class,
+ SendNotificationForAutoApplicationInitiated.class,
+ CourtApplicationUpdated.class,
+ ApplicationHearingDefendantUpdated.class
+ );
+
+ @Mock
+ private EventSource eventSource;
+
+ @Mock
+ private EventStream eventStream;
+
+ @Mock
+ private AggregateService aggregateService;
+
+ @Mock
+ private RefDataService referenceDataService;
+
+ @Mock
+ private ProgressionService progressionService;
+
+ @Mock
+ private ProsecutionCaseQueryService prosecutionCaseQueryService;
+
+ @Mock
+ private ApplicationDetailsEnrichmentService applicationDetailsEnrichmentService;
+
+ @Spy
+ @InjectMocks
+ private final ObjectToJsonObjectConverter objectToJsonObjectConverter =
+ new ObjectToJsonObjectConverter(new ObjectMapperProducer().objectMapper());
+
+ @Spy
+ private JsonObjectToObjectConverter jsonObjectToObjectConverter =
+ new JsonObjectConvertersFactory().jsonObjectToObjectConverter();
+
+ @Mock
+ private ApplicationAggregate applicationAggregateMock;
+
+ @InjectMocks
+ private CourtApplicationHandler courtApplicationHandler;
+
+ private UUID masterDefendantId;
+
+ @BeforeEach
+ void setUp() {
+ masterDefendantId = randomUUID();
+ }
+
+ // -----------------------------------------------------------------------
+ // AC1: Case hearing — MH source + ACTIVE case → offences must be nulled
+ // -----------------------------------------------------------------------
+
+ @Test
+ void shouldNullOffencesForActiveCaseWhenApplicationSourceIsMH() throws Exception {
+ final Offence activeOffence = offence()
+ .withId(randomUUID())
+ .withOffenceCode("OF001")
+ .withWording("Some wording")
+ .build();
+
+ final InitiateCourtApplicationProceedings command = initiateCourtApplicationProceedings()
+ .withApplicationSource(MH)
+ .withCourtApplication(courtApplication()
+ .withId(randomUUID())
+ .withType(courtApplicationType()
+ .withProsecutorThirdPartyFlag(false)
+ .withSummonsTemplateType(NOT_APPLICABLE)
+ .build())
+ .withApplicant(buildParty())
+ .withSubject(buildParty())
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ .withCaseStatus("ACTIVE")
+ .withOffences(singletonList(activeOffence))
+ .build()))
+ .build())
+ .withCourtHearing(CourtHearingRequest.courtHearingRequest().build())
+ .build();
+
+ final Envelope envelope = buildEnvelope(command);
+
+ final ApplicationAggregate aggregate = new ApplicationAggregate();
+ when(eventSource.getStreamById(any())).thenReturn(eventStream);
+ when(aggregateService.get(eventStream, ApplicationAggregate.class)).thenReturn(aggregate);
+ aggregate.apply(new CourtApplicationProceedingsInitiated.Builder()
+ .withCourtHearing(new CourtHearingRequest.Builder().build())
+ .withBoxHearing(new BoxHearingRequest.Builder().build())
+ .build());
+
+ courtApplicationHandler.initiateCourtApplicationProceedings(envelope);
+
+ final Stream envelopeStream = verifyAppendAndGetArgumentFrom(eventStream);
+
+ assertThat(envelopeStream, streamContaining(
+ jsonEnvelope(
+ metadata().withName("progression.event.court-application-proceedings-initiated"),
+ payload().isJson(allOf(
+ withJsonPath("$.courtApplication.courtApplicationCases[0].caseStatus", is("ACTIVE")),
+ hasNoJsonPath("$.courtApplication.courtApplicationCases[0].offences")
+ ))
+ )));
+ }
+
+ @Test
+ void shouldNullOffencesForMultipleCasesWhenAllAreActiveAndSourceIsMH() throws Exception {
+ final Offence offence = offence().withId(randomUUID()).withOffenceCode("OF002").build();
+
+ final InitiateCourtApplicationProceedings command = initiateCourtApplicationProceedings()
+ .withApplicationSource(MH)
+ .withCourtApplication(courtApplication()
+ .withId(randomUUID())
+ .withType(courtApplicationType()
+ .withProsecutorThirdPartyFlag(false)
+ .withSummonsTemplateType(NOT_APPLICABLE)
+ .build())
+ .withApplicant(buildParty())
+ .withSubject(buildParty())
+ .withCourtApplicationCases(asList(
+ courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ .withCaseStatus("ACTIVE")
+ .withOffences(singletonList(offence))
+ .build(),
+ courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ .withCaseStatus("ACTIVE")
+ .withOffences(singletonList(offence))
+ .build()))
+ .build())
+ .withCourtHearing(CourtHearingRequest.courtHearingRequest().build())
+ .build();
+
+ final Envelope envelope = buildEnvelope(command);
+
+ final ApplicationAggregate aggregate = new ApplicationAggregate();
+ when(eventSource.getStreamById(any())).thenReturn(eventStream);
+ when(aggregateService.get(eventStream, ApplicationAggregate.class)).thenReturn(aggregate);
+ aggregate.apply(new CourtApplicationProceedingsInitiated.Builder()
+ .withCourtHearing(new CourtHearingRequest.Builder().build())
+ .withBoxHearing(new BoxHearingRequest.Builder().build())
+ .build());
+
+ courtApplicationHandler.initiateCourtApplicationProceedings(envelope);
+
+ final Stream envelopeStream = verifyAppendAndGetArgumentFrom(eventStream);
+
+ assertThat(envelopeStream, streamContaining(
+ jsonEnvelope(
+ metadata().withName("progression.event.court-application-proceedings-initiated"),
+ payload().isJson(allOf(
+ hasNoJsonPath("$.courtApplication.courtApplicationCases[0].offences"),
+ hasNoJsonPath("$.courtApplication.courtApplicationCases[1].offences")
+ ))
+ )));
+ }
+
+ // -----------------------------------------------------------------------
+ // AC2: Application hearing — MH source + INACTIVE case → offences kept
+ // -----------------------------------------------------------------------
+
+ @Test
+ void shouldPreserveOffencesForInactiveCaseWhenApplicationSourceIsMH() throws Exception {
+ final UUID offenceId = randomUUID();
+ final Offence inactiveOffence = offence()
+ .withId(offenceId)
+ .withOffenceCode("OF003")
+ .withWording("Breach wording")
+ .build();
+
+ final InitiateCourtApplicationProceedings command = initiateCourtApplicationProceedings()
+ .withApplicationSource(MH)
+ .withCourtApplication(courtApplication()
+ .withId(randomUUID())
+ .withType(courtApplicationType()
+ .withProsecutorThirdPartyFlag(false)
+ .withSummonsTemplateType(NOT_APPLICABLE)
+ .build())
+ .withApplicant(buildParty())
+ .withSubject(buildParty())
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ .withCaseStatus("INACTIVE")
+ .withOffences(singletonList(inactiveOffence))
+ .build()))
+ .build())
+ .withCourtHearing(CourtHearingRequest.courtHearingRequest().build())
+ .build();
+
+ final Envelope envelope = buildEnvelope(command);
+
+ final ApplicationAggregate aggregate = new ApplicationAggregate();
+ when(eventSource.getStreamById(any())).thenReturn(eventStream);
+ when(aggregateService.get(eventStream, ApplicationAggregate.class)).thenReturn(aggregate);
+ aggregate.apply(new CourtApplicationProceedingsInitiated.Builder()
+ .withCourtHearing(new CourtHearingRequest.Builder().build())
+ .withBoxHearing(new BoxHearingRequest.Builder().build())
+ .build());
+
+ courtApplicationHandler.initiateCourtApplicationProceedings(envelope);
+
+ final Stream envelopeStream = verifyAppendAndGetArgumentFrom(eventStream);
+
+ assertThat(envelopeStream, streamContaining(
+ jsonEnvelope(
+ metadata().withName("progression.event.court-application-proceedings-initiated"),
+ payload().isJson(allOf(
+ withJsonPath("$.courtApplication.courtApplicationCases[0].caseStatus", is("INACTIVE")),
+ withJsonPath("$.courtApplication.courtApplicationCases[0].offences[0].id", is(offenceId.toString()))
+ ))
+ )));
+ }
+
+ @Test
+ void shouldPreserveOffencesForClosedCaseWhenApplicationSourceIsMH() throws Exception {
+ final UUID offenceId = randomUUID();
+ final Offence closedOffence = offence().withId(offenceId).withOffenceCode("OF004").build();
+
+ final InitiateCourtApplicationProceedings command = initiateCourtApplicationProceedings()
+ .withApplicationSource(MH)
+ .withCourtApplication(courtApplication()
+ .withId(randomUUID())
+ .withType(courtApplicationType()
+ .withProsecutorThirdPartyFlag(false)
+ .withSummonsTemplateType(NOT_APPLICABLE)
+ .build())
+ .withApplicant(buildParty())
+ .withSubject(buildParty())
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ .withCaseStatus("CLOSED")
+ .withOffences(singletonList(closedOffence))
+ .build()))
+ .build())
+ .withCourtHearing(CourtHearingRequest.courtHearingRequest().build())
+ .build();
+
+ final Envelope envelope = buildEnvelope(command);
+
+ final ApplicationAggregate aggregate = new ApplicationAggregate();
+ when(eventSource.getStreamById(any())).thenReturn(eventStream);
+ when(aggregateService.get(eventStream, ApplicationAggregate.class)).thenReturn(aggregate);
+ aggregate.apply(new CourtApplicationProceedingsInitiated.Builder()
+ .withCourtHearing(new CourtHearingRequest.Builder().build())
+ .withBoxHearing(new BoxHearingRequest.Builder().build())
+ .build());
+
+ courtApplicationHandler.initiateCourtApplicationProceedings(envelope);
+
+ final Stream envelopeStream = verifyAppendAndGetArgumentFrom(eventStream);
+
+ assertThat(envelopeStream, streamContaining(
+ jsonEnvelope(
+ metadata().withName("progression.event.court-application-proceedings-initiated"),
+ payload().isJson(allOf(
+ withJsonPath("$.courtApplication.courtApplicationCases[0].offences[0].id", is(offenceId.toString()))
+ ))
+ )));
+ }
+
+ // -----------------------------------------------------------------------
+ // Mixed cases: one ACTIVE (offences nulled), one INACTIVE (offences kept)
+ // -----------------------------------------------------------------------
+
+ @Test
+ void shouldNullOffencesOnlyForActiveCasesInMixedScenarioWithMHSource() throws Exception {
+ final UUID activeOffenceId = randomUUID();
+ final UUID inactiveOffenceId = randomUUID();
+
+ final InitiateCourtApplicationProceedings command = initiateCourtApplicationProceedings()
+ .withApplicationSource(MH)
+ .withCourtApplication(courtApplication()
+ .withId(randomUUID())
+ .withType(courtApplicationType()
+ .withProsecutorThirdPartyFlag(false)
+ .withSummonsTemplateType(NOT_APPLICABLE)
+ .build())
+ .withApplicant(buildParty())
+ .withSubject(buildParty())
+ .withCourtApplicationCases(asList(
+ courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ .withCaseStatus("ACTIVE")
+ .withOffences(singletonList(offence().withId(activeOffenceId).withOffenceCode("OF_A").build()))
+ .build(),
+ courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ .withCaseStatus("INACTIVE")
+ .withOffences(singletonList(offence().withId(inactiveOffenceId).withOffenceCode("OF_I").build()))
+ .build()))
+ .build())
+ .withCourtHearing(CourtHearingRequest.courtHearingRequest().build())
+ .build();
+
+ final Envelope envelope = buildEnvelope(command);
+
+ final ApplicationAggregate aggregate = new ApplicationAggregate();
+ when(eventSource.getStreamById(any())).thenReturn(eventStream);
+ when(aggregateService.get(eventStream, ApplicationAggregate.class)).thenReturn(aggregate);
+ aggregate.apply(new CourtApplicationProceedingsInitiated.Builder()
+ .withCourtHearing(new CourtHearingRequest.Builder().build())
+ .withBoxHearing(new BoxHearingRequest.Builder().build())
+ .build());
+
+ courtApplicationHandler.initiateCourtApplicationProceedings(envelope);
+
+ final Stream envelopeStream = verifyAppendAndGetArgumentFrom(eventStream);
+
+ assertThat(envelopeStream, streamContaining(
+ jsonEnvelope(
+ metadata().withName("progression.event.court-application-proceedings-initiated"),
+ payload().isJson(allOf(
+ hasNoJsonPath("$.courtApplication.courtApplicationCases[0].offences"),
+ withJsonPath("$.courtApplication.courtApplicationCases[1].offences[0].id", is(inactiveOffenceId.toString()))
+ ))
+ )));
+ }
+
+ // -----------------------------------------------------------------------
+ // Non-MH sources must NOT trigger the suppression (as-is behaviour)
+ // -----------------------------------------------------------------------
+
+ @Test
+ void shouldPreserveOffencesForActiveCaseWhenApplicationSourceIsHome() throws Exception {
+ final UUID offenceId = randomUUID();
+ shouldPreserveOffencesForActiveCaseWithSource(HOME, offenceId);
+ }
+
+ @Test
+ void shouldPreserveOffencesForActiveCaseWhenApplicationSourceIsCaag() throws Exception {
+ final UUID offenceId = randomUUID();
+ shouldPreserveOffencesForActiveCaseWithSource(CAAG, offenceId);
+ }
+
+ @Test
+ void shouldPreserveOffencesForActiveCaseWhenApplicationSourceIsUnknown() throws Exception {
+ final UUID offenceId = randomUUID();
+ shouldPreserveOffencesForActiveCaseWithSource(UNKNOWN, offenceId);
+ }
+
+ @Test
+ void shouldPreserveOffencesForActiveCaseWhenApplicationSourceIsNull() throws Exception {
+ final UUID offenceId = randomUUID();
+
+ final InitiateCourtApplicationProceedings command = initiateCourtApplicationProceedings()
+ // no .withApplicationSource() — field absent, getApplicationSource() returns null
+ .withCourtApplication(courtApplication()
+ .withId(randomUUID())
+ .withType(courtApplicationType()
+ .withProsecutorThirdPartyFlag(false)
+ .withSummonsTemplateType(NOT_APPLICABLE)
+ .build())
+ .withApplicant(buildParty())
+ .withSubject(buildParty())
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ .withCaseStatus("ACTIVE")
+ .withOffences(singletonList(offence().withId(offenceId).withOffenceCode("OF_NULL").build()))
+ .build()))
+ .build())
+ .withCourtHearing(CourtHearingRequest.courtHearingRequest().build())
+ .build();
+
+ final Envelope envelope = buildEnvelope(command);
+
+ final ApplicationAggregate aggregate = new ApplicationAggregate();
+ when(eventSource.getStreamById(any())).thenReturn(eventStream);
+ when(aggregateService.get(eventStream, ApplicationAggregate.class)).thenReturn(aggregate);
+ aggregate.apply(new CourtApplicationProceedingsInitiated.Builder()
+ .withCourtHearing(new CourtHearingRequest.Builder().build())
+ .withBoxHearing(new BoxHearingRequest.Builder().build())
+ .build());
+
+ courtApplicationHandler.initiateCourtApplicationProceedings(envelope);
+
+ final Stream envelopeStream = verifyAppendAndGetArgumentFrom(eventStream);
+
+ assertThat(envelopeStream, streamContaining(
+ jsonEnvelope(
+ metadata().withName("progression.event.court-application-proceedings-initiated"),
+ payload().isJson(
+ withJsonPath("$.courtApplication.courtApplicationCases[0].offences[0].id", is(offenceId.toString()))
+ )
+ )));
+ }
+
+ // -----------------------------------------------------------------------
+ // Edge case: null caseStatus with MH source — treat as non-active (keep offences)
+ // -----------------------------------------------------------------------
+
+ @Test
+ void shouldPreserveOffencesWhenCaseStatusIsNullAndSourceIsMH() throws Exception {
+ final UUID offenceId = randomUUID();
+
+ final InitiateCourtApplicationProceedings command = initiateCourtApplicationProceedings()
+ .withApplicationSource(MH)
+ .withCourtApplication(courtApplication()
+ .withId(randomUUID())
+ .withType(courtApplicationType()
+ .withProsecutorThirdPartyFlag(false)
+ .withSummonsTemplateType(NOT_APPLICABLE)
+ .build())
+ .withApplicant(buildParty())
+ .withSubject(buildParty())
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ // no .withCaseStatus() — null
+ .withOffences(singletonList(offence().withId(offenceId).withOffenceCode("OF_NULL_STATUS").build()))
+ .build()))
+ .build())
+ .withCourtHearing(CourtHearingRequest.courtHearingRequest().build())
+ .build();
+
+ final Envelope envelope = buildEnvelope(command);
+
+ final ApplicationAggregate aggregate = new ApplicationAggregate();
+ when(eventSource.getStreamById(any())).thenReturn(eventStream);
+ when(aggregateService.get(eventStream, ApplicationAggregate.class)).thenReturn(aggregate);
+ aggregate.apply(new CourtApplicationProceedingsInitiated.Builder()
+ .withCourtHearing(new CourtHearingRequest.Builder().build())
+ .withBoxHearing(new BoxHearingRequest.Builder().build())
+ .build());
+
+ courtApplicationHandler.initiateCourtApplicationProceedings(envelope);
+
+ final Stream envelopeStream = verifyAppendAndGetArgumentFrom(eventStream);
+
+ assertThat(envelopeStream, streamContaining(
+ jsonEnvelope(
+ metadata().withName("progression.event.court-application-proceedings-initiated"),
+ payload().isJson(
+ hasNoJsonPath("$.courtApplication.courtApplicationCases[0].offences"))
+ )));
+ }
+
+ // -----------------------------------------------------------------------
+ // MH source — case with no offences at all should not fail
+ // -----------------------------------------------------------------------
+
+ @Test
+ void shouldHandleActiveCaseWithNoOffencesWhenSourceIsMH() throws Exception {
+ final InitiateCourtApplicationProceedings command = initiateCourtApplicationProceedings()
+ .withApplicationSource(MH)
+ .withCourtApplication(courtApplication()
+ .withId(randomUUID())
+ .withType(courtApplicationType()
+ .withProsecutorThirdPartyFlag(false)
+ .withSummonsTemplateType(NOT_APPLICABLE)
+ .build())
+ .withApplicant(buildParty())
+ .withSubject(buildParty())
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ .withCaseStatus("ACTIVE")
+ // deliberately no offences
+ .build()))
+ .build())
+ .withCourtHearing(CourtHearingRequest.courtHearingRequest().build())
+ .build();
+
+ final Envelope envelope = buildEnvelope(command);
+
+ final ApplicationAggregate aggregate = new ApplicationAggregate();
+ when(eventSource.getStreamById(any())).thenReturn(eventStream);
+ when(aggregateService.get(eventStream, ApplicationAggregate.class)).thenReturn(aggregate);
+ aggregate.apply(new CourtApplicationProceedingsInitiated.Builder()
+ .withCourtHearing(new CourtHearingRequest.Builder().build())
+ .withBoxHearing(new BoxHearingRequest.Builder().build())
+ .build());
+
+ courtApplicationHandler.initiateCourtApplicationProceedings(envelope);
+
+ final Stream envelopeStream = verifyAppendAndGetArgumentFrom(eventStream);
+
+ assertThat(envelopeStream, streamContaining(
+ jsonEnvelope(
+ metadata().withName("progression.event.court-application-proceedings-initiated"),
+ payload().isJson(
+ hasNoJsonPath("$.courtApplication.courtApplicationCases[0].offences")
+ )
+ )));
+ }
+
+ // -----------------------------------------------------------------------
+ // Helpers
+ // -----------------------------------------------------------------------
+
+ private void shouldPreserveOffencesForActiveCaseWithSource(
+ final uk.gov.moj.cpp.progression.enums.ApplicationSource source,
+ final UUID offenceId) throws Exception {
+
+ final InitiateCourtApplicationProceedings command = initiateCourtApplicationProceedings()
+ .withApplicationSource(source)
+ .withCourtApplication(courtApplication()
+ .withId(randomUUID())
+ .withType(courtApplicationType()
+ .withProsecutorThirdPartyFlag(false)
+ .withSummonsTemplateType(NOT_APPLICABLE)
+ .build())
+ .withApplicant(buildParty())
+ .withSubject(buildParty())
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withIsSJP(false)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier().withCaseURN(STRING.next()).build())
+ .withCaseStatus("ACTIVE")
+ .withOffences(singletonList(offence().withId(offenceId).withOffenceCode("OF_NON_MH").build()))
+ .build()))
+ .build())
+ .withCourtHearing(CourtHearingRequest.courtHearingRequest().build())
+ .build();
+
+ final Envelope envelope = buildEnvelope(command);
+
+ final ApplicationAggregate aggregate = new ApplicationAggregate();
+ when(eventSource.getStreamById(any())).thenReturn(eventStream);
+ when(aggregateService.get(eventStream, ApplicationAggregate.class)).thenReturn(aggregate);
+ aggregate.apply(new CourtApplicationProceedingsInitiated.Builder()
+ .withCourtHearing(new CourtHearingRequest.Builder().build())
+ .withBoxHearing(new BoxHearingRequest.Builder().build())
+ .build());
+
+ courtApplicationHandler.initiateCourtApplicationProceedings(envelope);
+
+ final Stream envelopeStream = verifyAppendAndGetArgumentFrom(eventStream);
+
+ assertThat(envelopeStream, streamContaining(
+ jsonEnvelope(
+ metadata().withName("progression.event.court-application-proceedings-initiated"),
+ payload().isJson(
+ withJsonPath("$.courtApplication.courtApplicationCases[0].offences[0].id", is(offenceId.toString()))
+ )
+ )));
+ }
+
+ private Envelope buildEnvelope(final InitiateCourtApplicationProceedings command) {
+ final Metadata metadata = Envelope
+ .metadataBuilder()
+ .withName("progression.command.initiate-court-proceedings-for-application")
+ .withId(randomUUID())
+ .build();
+ return envelopeFrom(metadata, command);
+ }
+
+ private CourtApplicationParty buildParty() {
+ return CourtApplicationParty.courtApplicationParty()
+ .withId(randomUUID())
+ .withProsecutingAuthority(ProsecutingAuthority.prosecutingAuthority()
+ .withProsecutionAuthorityId(randomUUID())
+ .withProsecutionAuthorityCode("TEST_CODE")
+ .build())
+ .withMasterDefendant(MasterDefendant.masterDefendant()
+ .withMasterDefendantId(masterDefendantId)
+ .withPersonDefendant(PersonDefendant.personDefendant()
+ .withPersonDetails(Person.person()
+ .withAddress(Address.address()
+ .withAddress1("1 Test Street")
+ .withPostcode("TK1 1AA")
+ .build())
+ .build())
+ .build())
+ .build())
+ .build();
+ }
+}
diff --git a/progression-command/progression-command-handler/src/test/java/uk/gov/moj/cpp/progression/handler/CourtApplicationHandlerTest.java b/progression-command/progression-command-handler/src/test/java/uk/gov/moj/cpp/progression/handler/CourtApplicationHandlerTest.java
index 3cc975cc0..9167d08fb 100644
--- a/progression-command/progression-command-handler/src/test/java/uk/gov/moj/cpp/progression/handler/CourtApplicationHandlerTest.java
+++ b/progression-command/progression-command-handler/src/test/java/uk/gov/moj/cpp/progression/handler/CourtApplicationHandlerTest.java
@@ -115,6 +115,7 @@
import uk.gov.moj.cpp.progression.aggregate.ApplicationAggregate;
import uk.gov.moj.cpp.progression.aggregate.HearingAggregate;
import uk.gov.moj.cpp.progression.command.helper.FileResourceObjectMapper;
+import uk.gov.moj.cpp.progression.enums.ApplicationSource;
import uk.gov.moj.cpp.progression.service.ApplicationDetailsEnrichmentService;
import uk.gov.moj.cpp.progression.service.ProsecutionCaseQueryService;
import uk.gov.moj.cpp.progression.service.RefDataService;
@@ -3196,4 +3197,65 @@ public void shouldUpdateOffenceWordingForActiveCaseWhenNoCourtOrder() throws Eve
)
));
}
+
+ @Test
+ public void shouldIgnoreCaseOffencesWhenCaseStatusIsNullAndApplicationSourceIsMH() throws EventStreamException {
+ final UUID caseId = randomUUID();
+ final InitiateCourtApplicationProceedings initiateCourtApplicationProceedings = initiateCourtApplicationProceedings()
+ .withApplicationSource(ApplicationSource.MH)
+ .withCourtApplication(courtApplication()
+ .withApplicationReference(STRING.next())
+ .withId(randomUUID())
+ .withType(courtApplicationType()
+ .withLinkType(LinkType.LINKED)
+ .withProsecutorThirdPartyFlag(true)
+ .withSummonsTemplateType(NOT_APPLICABLE)
+ .build())
+ .withApplicant(buildCourtApplicationParty(prosecutor1))
+ .withRespondents(singletonList(buildCourtApplicationParty(respondent)))
+ .withSubject(buildCourtApplicationParty(subject))
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withIsSJP(false)
+ .withCaseStatus(null)
+ .withProsecutionCaseId(caseId)
+ .withProsecutionCaseIdentifier(prosecutionCaseIdentifier()
+ .withProsecutionAuthorityId(randomUUID()).build())
+ .withOffences(singletonList(Offence.offence()
+ .withOffenceCode(ORG_OFFENCE_CODE)
+ .withWording(ORG_OFFENCE_WORDING)
+ .withId(offenceId)
+ .build()))
+ .build()))
+ .build())
+ .withCourtHearing(buildCourtHearing(true))
+ .build();
+
+ final Metadata metadata = Envelope
+ .metadataBuilder()
+ .withName("progression.command.initiate-court-proceedings-for-application")
+ .withId(randomUUID())
+ .build();
+ final Envelope envelope = envelopeFrom(metadata, initiateCourtApplicationProceedings);
+
+ final ApplicationAggregate applicationAggregate = new ApplicationAggregate();
+ when(eventSource.getStreamById(any())).thenReturn(eventStream);
+ when(aggregateService.get(eventStream, ApplicationAggregate.class)).thenReturn(applicationAggregate);
+ applicationAggregate.apply(new CourtApplicationProceedingsInitiated.Builder()
+ .withCourtHearing(new CourtHearingRequest.Builder().build())
+ .withBoxHearing(new BoxHearingRequest.Builder().build())
+ .build());
+
+ courtApplicationHandler.initiateCourtApplicationProceedings(envelope);
+
+ final Stream envelopeStream = verifyAppendAndGetArgumentFrom(eventStream);
+ assertThat(envelopeStream, streamContaining(
+ jsonEnvelope(
+ metadata().withName("progression.event.court-application-proceedings-initiated"),
+ payload().isJson(allOf(
+ withJsonPath("$.courtApplication", notNullValue()),
+ hasNoJsonPath("$.courtApplication.courtApplicationCases[0].offences")
+ ))
+ )
+ ));
+ }
}
diff --git a/progression-domain/progression-datatypes-common/src/main/resources/json/schema/enum-def.json b/progression-domain/progression-datatypes-common/src/main/resources/json/schema/enum-def.json
index 5a0695ee9..ed8113ec5 100644
--- a/progression-domain/progression-datatypes-common/src/main/resources/json/schema/enum-def.json
+++ b/progression-domain/progression-datatypes-common/src/main/resources/json/schema/enum-def.json
@@ -66,6 +66,16 @@
"CONFIRMED",
"RESULTED"
]
+ },
+ "applicationSource": {
+ "id": "http://moj.gov.uk/cpp/progression/enums/application-source.json",
+ "type": "string",
+ "enum": [
+ "HOME",
+ "CAAG",
+ "MH",
+ "UNKNOWN"
+ ]
}
}
}
\ No newline at end of file
diff --git a/progression-domain/progression-domain-message/src/raml/json/schema/progression.command.initiate-court-proceedings-for-application.json b/progression-domain/progression-domain-message/src/raml/json/schema/progression.command.initiate-court-proceedings-for-application.json
index b5f025db7..72e73a1f0 100644
--- a/progression-domain/progression-domain-message/src/raml/json/schema/progression.command.initiate-court-proceedings-for-application.json
+++ b/progression-domain/progression-domain-message/src/raml/json/schema/progression.command.initiate-court-proceedings-for-application.json
@@ -20,6 +20,9 @@
"description": "Indicates that the summons approval process is required to be initiated",
"type": "boolean"
},
+ "applicationSource": {
+ "$ref": "http://moj.gov.uk/cpp/progression/enum-def.json#/definitions/applicationSource"
+ },
"isAmended": {
"type": "boolean"
},
diff --git a/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/processor/CourtApplicationProcessor.java b/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/processor/CourtApplicationProcessor.java
index accf39499..3a417c0c7 100644
--- a/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/processor/CourtApplicationProcessor.java
+++ b/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/processor/CourtApplicationProcessor.java
@@ -1,6 +1,7 @@
package uk.gov.moj.cpp.progression.processor;
+import static java.lang.Boolean.TRUE;
import static java.time.format.DateTimeFormatter.ofPattern;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
@@ -127,7 +128,6 @@
@SuppressWarnings({"squid:S2789", "squid:CallToDeprecatedMethod", "squid:CommentedOutCodeLine", "squid:UnusedPrivateMethod", "squid:S1192"})
public class CourtApplicationProcessor {
- public static final String PUBLIC_PROGRESSION_APPLICATION_DEFENDANT_CHANGED = "public.progression.application-defendant-changed";
private static final String COURT_APPLICATION = "courtApplication";
private static final String PROSECUTION_CASE = "prosecutionCase";
private static final String OLD_APPLICATION_ID = "oldApplicationId";
@@ -296,7 +296,7 @@ public void processCourtApplicationUpdated(final JsonEnvelope event) {
public void processCourtApplicationInitiated(final JsonEnvelope event) {
final CourtApplicationProceedingsInitiated courtApplicationProceedingsInitiated = jsonObjectToObjectConverter.convert(event.payloadAsJsonObject(), CourtApplicationProceedingsInitiated.class);
- if (Boolean.TRUE.equals(courtApplicationProceedingsInitiated.getIsSJP())) {
+ if (TRUE.equals(courtApplicationProceedingsInitiated.getIsSJP())) {
initiateSJPCase(event, courtApplicationProceedingsInitiated);
} else {
initiateCourtApplication(event, courtApplicationProceedingsInitiated.getCourtApplication(), courtApplicationProceedingsInitiated.getOldApplicationId());
@@ -545,7 +545,9 @@ public void processBoxWorkApplication(final JsonEnvelope jsonEnvelope) {
hearingBuilder.withIsVirtualBoxHearing(true);
}
- final Initiate hearingInitiate = Initiate.initiate().withHearing(hearingBuilder.build()).build();
+ final Hearing hearing = progressionService.shapeHearingForListing(hearingBuilder.build(), jsonEnvelope);
+
+ final Initiate hearingInitiate = Initiate.initiate().withHearing(hearing).build();
progressionService.linkApplicationToHearing(jsonEnvelope, hearingInitiate.getHearing(), HearingListingStatus.HEARING_INITIALISED);
@@ -580,7 +582,7 @@ public void processCourtApplicationReferredToCourtHearing(final JsonEnvelope eve
final List prosecutionCases = getProsecutionCases(event, application);
- final Hearing hearing = hearing()
+ final Hearing rawHearing = hearing()
.withProsecutionCases(prosecutionCases)
.withId(courtHearing.getId())
.withHearingDays(singletonList(hearingDay()
@@ -596,6 +598,8 @@ public void processCourtApplicationReferredToCourtHearing(final JsonEnvelope eve
.withSpecialRequirements(courtHearing.getSpecialRequirements())
.build();
+ final Hearing hearing = progressionService.shapeHearingForListing(rawHearing, event);
+
final Initiate hearingInitiate = Initiate.initiate().withHearing(hearing).build();
progressionService.linkApplicationToHearing(event, hearingInitiate.getHearing(), HearingListingStatus.HEARING_INITIALISED);
@@ -606,7 +610,12 @@ public void processCourtApplicationReferredToCourtHearing(final JsonEnvelope eve
// then update application status - hearing initiated in the Listing hence applicationStatus == UN_ALLOCATED
progressionService.updateCourtApplicationStatus(event, application.getId(), ApplicationStatus.UN_ALLOCATED);
- final ListCourtHearing listCourtHearing = buildDefaultHearingNeeds(applicationReferredToCourtHearing.getCourtHearing(), application, prosecutionCases);
+ // build the listing needs from the filtered hearing so the application/prosecutionCases sent to
+ // listing match the shaped hearing (e.g. an application hearing carries no prosecution case)
+ final List filteredCourtApplications = hearingInitiate.getHearing().getCourtApplications();
+ final CourtApplication listingApplication = isNotEmpty(filteredCourtApplications) ? filteredCourtApplications.get(0) : application;
+ final ListCourtHearing listCourtHearing = buildDefaultHearingNeeds(applicationReferredToCourtHearing.getCourtHearing(),
+ listingApplication, hearingInitiate.getHearing().getProsecutionCases());
// then list hearing
listingService.listCourtHearing(event, listCourtHearing);
}
@@ -874,7 +883,7 @@ public void processBreachApplicationCreationRequested(final JsonEnvelope event)
private List getProsecutionCases(final JsonEnvelope event, final CourtApplication application) {
final List prosecutionCases = new ArrayList<>();
final Stream courtApplicationCases = ofNullable(application.getCourtApplicationCases()).map(Collection::stream).orElseGet(Stream::empty);
- if (isAllActiveCases(courtApplicationCases)) {
+ if (isAllActiveCasesByOffenceStatus(courtApplicationCases)) {
ofNullable(application.getCourtApplicationCases()).map(Collection::stream).orElseGet(Stream::empty).forEach(courtApplicationCase -> {
final Optional prosecutionCaseDetailById = progressionService.getProsecutionCaseDetailById(event, courtApplicationCase.getProsecutionCaseId().toString());
if (prosecutionCaseDetailById.isPresent()) {
@@ -966,14 +975,26 @@ public void processApplicationDefendantUpdateRequested(final JsonEnvelope event)
private Predicate distinctByKey(final Function keyExtractor) {
final Map map = new ConcurrentHashMap<>();
- return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
+ return t -> map.putIfAbsent(keyExtractor.apply(t), TRUE) == null;
}
- private boolean isAllActiveCases(final Stream courtApplicationCases) {
- return courtApplicationCases
- .allMatch(courtApplicationCase -> nonNull(courtApplicationCase.getCaseStatus())
- && !"INACTIVE".equalsIgnoreCase(courtApplicationCase.getCaseStatus())
- && !"CLOSED".equalsIgnoreCase(courtApplicationCase.getCaseStatus()));
+ /**
+ * Determines whether every court application case is active, based on its offences' proceedings
+ * status. A case with offences is INACTIVE only when all its offences have
+ * {@code proceedingsConcluded == true}, otherwise it is ACTIVE. A case with no offences falls
+ * back to the {@code caseStatus} check.
+ */
+ private boolean isAllActiveCasesByOffenceStatus(final Stream courtApplicationCases) {
+ return courtApplicationCases.allMatch(this::isActiveCaseByOffenceStatus);
+ }
+
+ // package-private for unit testing
+ boolean isActiveCaseByOffenceStatus(final CourtApplicationCase courtApplicationCase) {
+ if (isNotEmpty(courtApplicationCase.getOffences())) {
+ return courtApplicationCase.getOffences().stream()
+ .anyMatch(offence -> !TRUE.equals(offence.getProceedingsConcluded()));
+ }
+ return !"INACTIVE".equalsIgnoreCase(courtApplicationCase.getCaseStatus()) && !"CLOSED".equalsIgnoreCase(courtApplicationCase.getCaseStatus());
}
private Optional findFirstProsecutionCaseForMasterDefendant(final Hearing hearing, final UUID masterDefendantId) {
@@ -1043,7 +1064,7 @@ private Hearing updateHearingWithApplication(final JsonEnvelope event, final Hea
final Stream courtApplicationCases = ofNullable(courtApplication.getCourtApplicationCases()).map(Collection::stream).orElseGet(Stream::empty);
- if (isAllActiveCases(courtApplicationCases) && isNotEmpty(hearing.getProsecutionCases())) {
+ if (isAllActiveCasesByOffenceStatus(courtApplicationCases) && isNotEmpty(hearing.getProsecutionCases())) {
final List courtApplicationCasesForWhichWeNeedToCreateHearing = ofNullable(courtApplication.getCourtApplicationCases()).map(Collection::stream).orElseGet(Stream::empty)
.filter(courtApplicationCase -> hearing.getProsecutionCases().stream().noneMatch(prosecutionCase -> courtApplicationCase.getProsecutionCaseId().equals(prosecutionCase.getId())))
.collect(toList());
diff --git a/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/processor/HearingConfirmedEventProcessor.java b/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/processor/HearingConfirmedEventProcessor.java
index 174b6306c..58356e5ed 100644
--- a/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/processor/HearingConfirmedEventProcessor.java
+++ b/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/processor/HearingConfirmedEventProcessor.java
@@ -230,8 +230,10 @@ private void confirmHearing(final JsonEnvelope jsonEnvelope, final boolean sendN
final SeedingHearing seedingHearing = hearingInProgression.getSeedingHearing();
+ // hearingInProgression used for the prosecution-case order: an existing hearing's own
+ // cases must stay first in the payload
final Initiate hearingInitiate = Initiate.initiate()
- .withHearing(progressionService.transformConfirmedHearing(confirmedHearing, jsonEnvelope, seedingHearing))
+ .withHearing(progressionService.transformConfirmedHearing(confirmedHearing, jsonEnvelope, seedingHearing, hearingInProgression))
.build();
List deltaProsecutionCases = Collections.emptyList();
@@ -574,12 +576,19 @@ public void processHearingInitiatedEnrichedEvent(JsonEnvelope jsonEnvelope) {
LOGGER.info(" hearing initiate with payload {}", jsonEnvelope.toObfuscatedDebugString());
- final Initiate hearingInitiate = jsonObjectConverter.convert(jsonEnvelope.payloadAsJsonObject(), Initiate.class);
+ final Initiate incomingHearingInitiate = jsonObjectConverter.convert(jsonEnvelope.payloadAsJsonObject(), Initiate.class);
- sender.send(enveloper.withMetadataFrom(jsonEnvelope, HEARING_INITIATE_COMMAND).apply(objectToJsonObjectConverter.convert(hearingInitiate)));
- if (isNotEmpty(hearingInitiate.getHearing().getProsecutionCases())) {
+ // Preserving variant: the enriched hearing comes from a confirmed (possibly next/adjourned)
+ // hearing whose case offences pre-exist independently of the application and must not be dropped.
+ final Initiate filteredHearingInitiate = Initiate.initiate()
+ .withValuesFrom(incomingHearingInitiate)
+ .withHearing(progressionService.shapeExistingHearingForListing(incomingHearingInitiate.getHearing(), jsonEnvelope))
+ .build();
+
+ sender.send(enveloper.withMetadataFrom(jsonEnvelope, HEARING_INITIATE_COMMAND).apply(objectToJsonObjectConverter.convert(filteredHearingInitiate)));
+ if (isNotEmpty(filteredHearingInitiate.getHearing().getProsecutionCases())) {
final List prosecutionCasesReferredToCourts = ProsecutionCasesReferredToCourtTransformer
- .transform(hearingInitiate, null);
+ .transform(filteredHearingInitiate, null);
prosecutionCasesReferredToCourts.forEach(prosecutionCasesReferredToCourt -> {
final JsonObject prosecutionCasesReferredToCourtJson = objectToJsonObjectConverter.convert(prosecutionCasesReferredToCourt);
@@ -591,10 +600,10 @@ public void processHearingInitiatedEnrichedEvent(JsonEnvelope jsonEnvelope) {
sender.send(caseReferToCourt);
});
- progressionService.updateHearingListingStatusToHearingInitiated(jsonEnvelope, hearingInitiate);
+ progressionService.updateHearingListingStatusToHearingInitiated(jsonEnvelope, filteredHearingInitiate);
} else {
- LOGGER.info("hearing-confirmed event populate hearing to probation caseworker for hearingId '{}' ", hearingInitiate.getHearing().getId());
- progressionService.populateHearingToProbationCaseworker(jsonEnvelope, hearingInitiate.getHearing().getId());
+ LOGGER.info("hearing-confirmed event populate hearing to probation caseworker for hearingId '{}' ", filteredHearingInitiate.getHearing().getId());
+ progressionService.populateHearingToProbationCaseworker(jsonEnvelope, filteredHearingInitiate.getHearing().getId());
}
}
diff --git a/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/service/PartialHearingConfirmService.java b/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/service/PartialHearingConfirmService.java
index 5c5d44881..268c60d9f 100644
--- a/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/service/PartialHearingConfirmService.java
+++ b/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/service/PartialHearingConfirmService.java
@@ -43,7 +43,7 @@ public class PartialHearingConfirmService {
private static final Integer ESTIMATED_MINUTES = 30;
- public List getDifferences(final ConfirmedHearing confirmedHearing, final Hearing hearing) {
+ public List getDifferences(final ConfirmedHearing confirmedHearing, final Hearing hearingInProgression) {
if (isNotEmpty(confirmedHearing.getProsecutionCases())) {
@@ -56,8 +56,8 @@ public List getDifferences(final ConfirmedHearing confirmedHear
.collect(toList());
final Hearing cloneHearing = Hearing.hearing()
- .withValuesFrom(hearing)
- .withProsecutionCases(hearing.getProsecutionCases().stream()
+ .withValuesFrom(hearingInProgression)
+ .withProsecutionCases(hearingInProgression.getProsecutionCases().stream()
.map(pc -> ProsecutionCase.prosecutionCase().withValuesFrom(pc)
.withDefendants(pc.getDefendants().stream().map(defendant -> Defendant.defendant().withValuesFrom(defendant)
.withOffences(defendant.getOffences().stream().map(offence -> Offence.offence().withValuesFrom(offence).build()).collect(toList()))
diff --git a/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/service/ProgressionService.java b/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/service/ProgressionService.java
index f17ba4d78..3b34ac204 100644
--- a/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/service/ProgressionService.java
+++ b/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/service/ProgressionService.java
@@ -2,6 +2,7 @@
import static java.lang.Boolean.TRUE;
import static java.util.Collections.singletonList;
+import static java.util.Comparator.comparingInt;
import static java.util.Objects.isNull;
import static java.util.Objects.nonNull;
import static java.util.Optional.ofNullable;
@@ -102,6 +103,7 @@
import uk.gov.moj.cpp.progression.exception.ReferenceDataNotFoundException;
import uk.gov.moj.cpp.progression.model.HearingListing;
import uk.gov.moj.cpp.progression.processor.exceptions.CourtApplicationAndCaseNotFoundException;
+import uk.gov.moj.cpp.progression.transformer.HearingOffenceFilter;
import uk.gov.moj.cpp.systemusers.ServiceContextSystemUserProvider;
import java.io.IOException;
@@ -113,6 +115,7 @@
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
@@ -972,7 +975,11 @@ public void updateHearingListingStatusToSentForListing(final JsonEnvelope jsonEn
});
}
- private void updateHearingListingStatusToSentForListing(final JsonEnvelope jsonEnvelope, final List listHearingRequests, final Hearing hearing) {
+ private void updateHearingListingStatusToSentForListing(final JsonEnvelope jsonEnvelope, final List listHearingRequests, final Hearing rawHearing) {
+ // Preserving variant: the request may be a next/adjourned hearing carrying case offences that
+ // pre-exist independently of the application - they must stay so the projection routes it as a
+ // case hearing (SENT_FOR_LISTING) and not down the application-hearing branch below.
+ final Hearing hearing = shapeExistingHearingForListing(rawHearing, jsonEnvelope);
if (isNotEmpty(hearing.getProsecutionCases())) {
final JsonObjectBuilder hearingListingStatusCommandBuilder = Json.createObjectBuilder()
.add(HEARING_LISTING_STATUS, SENT_FOR_LISTING)
@@ -1343,10 +1350,28 @@ public Hearing transformConfirmedHearing(final ConfirmedHearing confirmedHearing
* @return
*/
public Hearing transformConfirmedHearing(final ConfirmedHearing confirmedHearing, final JsonEnvelope jsonEnvelope, final SeedingHearing seedingHearing) {
+ return transformConfirmedHearing(confirmedHearing, jsonEnvelope, seedingHearing, null);
+ }
+
+ /**
+ * Transform ConfirmedHearing to Hearing, ordering the prosecution cases against the hearing as
+ * progression already knows it: cases that were on the hearing before this confirmation keep
+ * their stored relative order and come first; newly arriving cases (e.g. adjourned onto an
+ * existing hearing) are appended. The manage-hearing display follows the payload order, so
+ * without the anchor an existing hearing's own case would render after the incoming one.
+ *
+ * @param confirmedHearing
+ * @param jsonEnvelope
+ * @param seedingHearing
+ * @param hearingInProgression progression's stored copy of the hearing (order anchor); null for
+ * hearings progression does not know yet
+ * @return
+ */
+ public Hearing transformConfirmedHearing(final ConfirmedHearing confirmedHearing, final JsonEnvelope jsonEnvelope, final SeedingHearing seedingHearing, final Hearing hearingInProgression) {
final LocalDate earliestHearingDate = getEarliestDate(confirmedHearing.getHearingDays()).toLocalDate();
- return Hearing.hearing()
+ final Hearing hearing = Hearing.hearing()
.withHearingDays(confirmedHearing.getHearingDays())
.withCourtCentre(transformCourtCentre(confirmedHearing.getCourtCentre(), jsonEnvelope))
.withJurisdictionType(confirmedHearing.getJurisdictionType())
@@ -1362,6 +1387,113 @@ public Hearing transformConfirmedHearing(final ConfirmedHearing confirmedHearing
.withEstimatedDuration(confirmedHearing.getEstimatedDuration())
.withIsGroupProceedings(confirmedHearing.getIsGroupProceedings())
.build();
+
+ // Shape application/case offences once, at the source, so the persisted hearing matches the
+ // manage-hearing view (CHD-2556): active application offences move to the prosecution side and
+ // concluded ones stay with the application. A confirmed hearing may pre-exist and carry its own
+ // listed case offences (adjourn/next-hearing), so use the preserving variant — those case offences must never be dropped.
+ final Hearing shapedHearing = HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(hearing, offenceOwnerResolver(jsonEnvelope));
+
+ return reorderProsecutionCasesByExistingHearing(shapedHearing, hearingInProgression);
+ }
+
+ /**
+ * Stable partition of the shaped hearing's prosecution cases against the hearing progression
+ * already holds: anchored cases first in the stored copy's relative order, the rest appended in
+ * their incoming order. Pure reordering — case content is never touched.
+ */
+ // package-private for unit testing
+ Hearing reorderProsecutionCasesByExistingHearing(final Hearing hearing, final Hearing hearingInProgression) {
+ if (isNull(hearingInProgression) || isEmpty(hearingInProgression.getProsecutionCases())
+ || isNull(hearing) || isEmpty(hearing.getProsecutionCases())) {
+ return hearing;
+ }
+
+ final List anchorOrder = hearingInProgression.getProsecutionCases().stream()
+ .map(ProsecutionCase::getId)
+ .collect(toList());
+
+ final List anchored = new ArrayList<>();
+ final List arriving = new ArrayList<>();
+ hearing.getProsecutionCases().forEach(prosecutionCase -> {
+ if (anchorOrder.contains(prosecutionCase.getId())) {
+ anchored.add(prosecutionCase);
+ } else {
+ arriving.add(prosecutionCase);
+ }
+ });
+
+ if (anchored.isEmpty()) {
+ return hearing;
+ }
+
+ anchored.sort(comparingInt(prosecutionCase -> anchorOrder.indexOf(prosecutionCase.getId())));
+
+ final List reordered = new ArrayList<>(anchored);
+ reordered.addAll(arriving);
+
+ return Hearing.hearing().withValuesFrom(hearing).withProsecutionCases(reordered).build();
+ }
+
+ /**
+ * Shapes an application-derived hearing (referral/boxwork creation flows) for listing: the
+ * hearing was just built from the application, so its prosecution side can only contain the
+ * application's own case — an application hearing (all application offences concluded) drops its
+ * prosecutionCases; active application offences move to the prosecution side and unreferenced
+ * case offences are dropped. Case-only hearings (no court applications) are returned unchanged.
+ * For hearings that already exist / were confirmed by listing use
+ * {@link #shapeExistingHearingForListing} instead.
+ */
+ public Hearing shapeHearingForListing(final Hearing hearing, final JsonEnvelope jsonEnvelope) {
+ return HearingOffenceFilter.filterOffences(hearing, offenceOwnerResolver(jsonEnvelope));
+ }
+
+ /**
+ * Shapes a merged/existing hearing (confirmed by listing, adjourn/next-hearing, extend) whose
+ * prosecution side carries legitimately listed case offences: those are preserved; only the
+ * application's own offences are shaped (concluded ones stay under the application and are
+ * deduped off the prosecution side, active ones move to the prosecution side).
+ */
+ public Hearing shapeExistingHearingForListing(final Hearing hearing, final JsonEnvelope jsonEnvelope) {
+ return HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(hearing, offenceOwnerResolver(jsonEnvelope));
+ }
+
+ /**
+ * Builds an offence-owner resolver that fetches each prosecution case from the view store at most once
+ * per call (memoised by prosecutionCaseId), so multiple offences belonging to the same case do not
+ * trigger repeated API lookups. Used as a fallback when an active application offence is not already
+ * present under the prosecutionCases.
+ */
+ HearingOffenceFilter.OffenceOwnerResolver offenceOwnerResolver(final JsonEnvelope jsonEnvelope) {
+ final Map> caseCache = new HashMap<>();
+ return (prosecutionCaseId, offenceId) -> {
+ if (isNull(prosecutionCaseId)) {
+ return Optional.empty();
+ }
+ return caseCache.computeIfAbsent(prosecutionCaseId, id -> fetchProsecutionCase(jsonEnvelope, id))
+ .flatMap(prosecutionCase -> findOwningDefendantId(prosecutionCase, offenceId));
+ };
+ }
+
+ private Optional fetchProsecutionCase(final JsonEnvelope jsonEnvelope, final UUID prosecutionCaseId) {
+ try {
+ final JsonObject prosecutionCaseJson = getProsecutionCaseById(jsonEnvelope, prosecutionCaseId.toString());
+ return Optional.ofNullable(jsonObjectConverter.convert(prosecutionCaseJson.getJsonObject("prosecutionCase"), ProsecutionCase.class));
+ } catch (final RuntimeException e) {
+ LOGGER.warn("Unable to fetch prosecution case {}: {}", prosecutionCaseId, e.getMessage());
+ return Optional.empty();
+ }
+ }
+
+ private static Optional findOwningDefendantId(final ProsecutionCase prosecutionCase, final UUID offenceId) {
+ if (isNull(prosecutionCase.getDefendants())) {
+ return Optional.empty();
+ }
+ return prosecutionCase.getDefendants().stream()
+ .filter(defendant -> nonNull(defendant.getOffences()))
+ .filter(defendant -> defendant.getOffences().stream().anyMatch(offence -> offenceId.equals(offence.getId())))
+ .map(Defendant::getId)
+ .findFirst();
}
public Hearing updateHearingForHearingUpdated(final ConfirmedHearing confirmedHearing, final JsonEnvelope jsonEnvelope, final Hearing hearing) {
diff --git a/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/transformer/HearingOffenceFilter.java b/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/transformer/HearingOffenceFilter.java
new file mode 100644
index 000000000..31b1b4b3a
--- /dev/null
+++ b/progression-event/progression-event-processor/src/main/java/uk/gov/moj/cpp/progression/transformer/HearingOffenceFilter.java
@@ -0,0 +1,340 @@
+package uk.gov.moj.cpp.progression.transformer;
+
+import static java.util.Collections.emptyList;
+import static java.util.Objects.isNull;
+import static java.util.Objects.nonNull;
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.Collectors.toSet;
+import static org.apache.commons.collections.CollectionUtils.isEmpty;
+import static org.apache.commons.collections.CollectionUtils.isNotEmpty;
+import static org.apache.commons.lang3.BooleanUtils.isTrue;
+
+import uk.gov.justice.core.courts.CourtApplication;
+import uk.gov.justice.core.courts.CourtApplicationCase;
+import uk.gov.justice.core.courts.Defendant;
+import uk.gov.justice.core.courts.Hearing;
+import uk.gov.justice.core.courts.Offence;
+import uk.gov.justice.core.courts.ProsecutionCase;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Filter the case level and application level offences carried by a hearing before it is sent to
+ * hearing context.
+ *
+ * Filtration applied to the hearing payload only — the application held in progression viewstore is
+ * a separate, untouched copy. A concluded offence belongs under courtApplicationCases; an active
+ * offence must never sit there and is moved to the prosecutionCases side.
+ *
+ * Two variants, chosen by the caller based on the hearing's provenance:
+ *
+ * - {@link #filterOffences} — strict, for a hearing just derived from the application
+ * (referral/boxwork creation flows): its prosecution side can only contain the application's own
+ * case, so unreferenced offences are dropped and, when all application offences are concluded,
+ * prosecutionCases is dropped entirely.
+ * - {@link #filterOffencesPreservingHearingCaseOffences} — for a merged/existing hearing
+ * (confirmed by listing, adjourn/next-hearing, extend): its prosecution side carries legitimately
+ * listed case offences that must never be lost; only the application's own offences are
+ * deduped/moved.
+ *
+ */
+public final class HearingOffenceFilter {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(HearingOffenceFilter.class);
+
+ private HearingOffenceFilter() {
+ }
+
+ /**
+ * Resolves the defendant that owns an offence within a prosecution case. Used only as a
+ * fallback when an active application offence is not already present under the hearing's
+ * prosecution cases.
+ */
+ @FunctionalInterface
+ public interface OffenceOwnerResolver {
+ Optional resolveDefendantIdByOffenceId(UUID prosecutionCaseId, UUID offenceId);
+ }
+
+ public static Hearing filterOffences(final Hearing hearing, final OffenceOwnerResolver ownerResolver) {
+ if (isNull(hearing) || isEmpty(hearing.getCourtApplications()) || !hasApplicationOffences(hearing.getCourtApplications())) {
+ return hearing;
+ }
+
+ // Application hearing: every application offence is concluded -> keep the application, drop prosecution cases.
+ if (allApplicationOffencesConcluded(hearing.getCourtApplications())) {
+ return Hearing.hearing().withValuesFrom(hearing).withProsecutionCases(null).build();
+ }
+
+ // Active offences exist under the application -> move them to the prosecution side.
+ final Set activeApplicationOffenceIds = hearing.getCourtApplications().stream()
+ .filter(application -> nonNull(application.getCourtApplicationCases()))
+ .flatMap(application -> application.getCourtApplicationCases().stream())
+ .filter(applicationCase -> nonNull(applicationCase.getOffences()))
+ .flatMap(applicationCase -> applicationCase.getOffences().stream())
+ .filter(HearingOffenceFilter::isActive)
+ .map(Offence::getId)
+ .collect(toSet());
+
+ // Working copy of the prosecution cases keeping only the active offences the application references.
+ final List workingProsecutionCases = copyKeepingReferencedOffences(hearing.getProsecutionCases(), activeApplicationOffenceIds);
+
+ // Offence ids now present under the prosecution side ("kept"/deduped).
+ final Set movedOffenceIds = collectOffenceIds(workingProsecutionCases);
+
+ // Fallback: any active application offence not yet present under prosecution -> move it across.
+ addMissingActiveOffences(hearing.getCourtApplications(), movedOffenceIds, workingProsecutionCases, ownerResolver);
+
+ final List filteredApplications = removeMovedOffencesFromApplications(hearing.getCourtApplications(), movedOffenceIds);
+ final List filteredProsecutionCases = dropEmptyDefendantsAndCases(workingProsecutionCases);
+
+ return Hearing.hearing()
+ .withValuesFrom(hearing)
+ .withCourtApplications(filteredApplications)
+ .withProsecutionCases(isEmpty(filteredProsecutionCases) ? null : filteredProsecutionCases)
+ .build();
+ }
+
+ /**
+ * Variant for merged/existing hearings (confirmed by listing, adjourn/next-hearing, extend).
+ * Unlike filterOffences, the prosecution side is preserved as-is — its case offences
+ * are listed on the hearing and are never dropped. Only the application's own
+ * offences are shaped: concluded application offences stay under the application (and are
+ * deduped off the prosecution side); active application offences move to the prosecution side
+ * under their owning defendant.
+ */
+ public static Hearing filterOffencesPreservingHearingCaseOffences(final Hearing hearing, final OffenceOwnerResolver ownerResolver) {
+ if (isNull(hearing) || isEmpty(hearing.getCourtApplications()) || !hasApplicationOffences(hearing.getCourtApplications())) {
+ return hearing;
+ }
+
+ // A concluded application offence lives under the application only -> dedup it off the prosecution side.
+ final Set concludedApplicationOffenceIds = collectConcludedApplicationOffenceIds(hearing.getCourtApplications());
+
+ // Working copy keeping every case offence the hearing already carries, minus the concluded
+ // application offences (dedup) - never rebuild the prosecution side from the application.
+ final List workingProsecutionCases = copyRemovingOffences(hearing.getProsecutionCases(), concludedApplicationOffenceIds);
+
+ // Offence ids present under the prosecution side.
+ final Set prosecutionOffenceIds = collectOffenceIds(workingProsecutionCases);
+
+ // Any active application offence not yet present under prosecution -> move it across.
+ addMissingActiveOffences(hearing.getCourtApplications(), prosecutionOffenceIds, workingProsecutionCases, ownerResolver);
+
+ // Strip from the application side the offences now present under prosecution: that covers the
+ // active application offences (moved or already there); concluded ones were deduped off the
+ // working copy above, so they stay with the application. Unrelated case offence ids are not on
+ // the application, so they are a no-op here.
+ final List filteredApplications = removeMovedOffencesFromApplications(hearing.getCourtApplications(), prosecutionOffenceIds);
+ final List filteredProsecutionCases = dropEmptyDefendantsAndCases(workingProsecutionCases);
+
+ return Hearing.hearing()
+ .withValuesFrom(hearing)
+ .withCourtApplications(filteredApplications)
+ .withProsecutionCases(isEmpty(filteredProsecutionCases) ? null : filteredProsecutionCases)
+ .build();
+ }
+
+ private static boolean hasApplicationOffences(final List applications) {
+ return applications.stream()
+ .filter(application -> nonNull(application.getCourtApplicationCases()))
+ .flatMap(application -> application.getCourtApplicationCases().stream())
+ .anyMatch(applicationCase -> isNotEmpty(applicationCase.getOffences()));
+ }
+
+ private static boolean allApplicationOffencesConcluded(final List applications) {
+ return applications.stream()
+ .filter(application -> nonNull(application.getCourtApplicationCases()))
+ .flatMap(application -> application.getCourtApplicationCases().stream())
+ .filter(applicationCase -> isNotEmpty(applicationCase.getOffences()))
+ .flatMap(applicationCase -> applicationCase.getOffences().stream())
+ .allMatch(HearingOffenceFilter::isConcluded);
+ }
+
+ private static List copyKeepingReferencedOffences(final List prosecutionCases, final Set referencedOffenceIds) {
+ if (isEmpty(prosecutionCases)) {
+ return new ArrayList<>();
+ }
+ return prosecutionCases.stream()
+ .map(prosecutionCase -> ProsecutionCase.prosecutionCase()
+ .withValuesFrom(prosecutionCase)
+ .withDefendants(copyDefendantsKeepingReferencedOffences(prosecutionCase.getDefendants(), referencedOffenceIds))
+ .build())
+ .collect(toList());
+ }
+
+ private static List copyDefendantsKeepingReferencedOffences(final List defendants, final Set referencedOffenceIds) {
+ if (isEmpty(defendants)) {
+ return new ArrayList<>();
+ }
+ return defendants.stream()
+ .map(defendant -> {
+ final List keptOffences = isNull(defendant.getOffences()) ? new ArrayList<>()
+ : defendant.getOffences().stream()
+ .filter(offence -> referencedOffenceIds.contains(offence.getId()))
+ .collect(toList());
+ return Defendant.defendant().withValuesFrom(defendant).withOffences(keptOffences).build();
+ })
+ .collect(toList());
+ }
+
+ private static Set collectConcludedApplicationOffenceIds(final List applications) {
+ return applications.stream()
+ .filter(application -> nonNull(application.getCourtApplicationCases()))
+ .flatMap(application -> application.getCourtApplicationCases().stream())
+ .filter(applicationCase -> nonNull(applicationCase.getOffences()))
+ .flatMap(applicationCase -> applicationCase.getOffences().stream())
+ .filter(HearingOffenceFilter::isConcluded)
+ .map(Offence::getId)
+ .collect(toSet());
+ }
+
+ private static List copyRemovingOffences(final List prosecutionCases, final Set offenceIdsToRemove) {
+ if (isEmpty(prosecutionCases)) {
+ return new ArrayList<>();
+ }
+ return prosecutionCases.stream()
+ .map(prosecutionCase -> ProsecutionCase.prosecutionCase()
+ .withValuesFrom(prosecutionCase)
+ .withDefendants(copyDefendantsRemovingOffences(prosecutionCase.getDefendants(), offenceIdsToRemove))
+ .build())
+ .collect(toList());
+ }
+
+ private static List copyDefendantsRemovingOffences(final List defendants, final Set offenceIdsToRemove) {
+ if (isEmpty(defendants)) {
+ return new ArrayList<>();
+ }
+ return defendants.stream()
+ .map(defendant -> {
+ final List keptOffences = isNull(defendant.getOffences()) ? new ArrayList<>()
+ : defendant.getOffences().stream()
+ .filter(offence -> !offenceIdsToRemove.contains(offence.getId()))
+ .collect(toList());
+ return Defendant.defendant().withValuesFrom(defendant).withOffences(keptOffences).build();
+ })
+ .collect(toList());
+ }
+
+ private static void addMissingActiveOffences(final List applications,
+ final Set movedOffenceIds,
+ final List workingProsecutionCases,
+ final OffenceOwnerResolver ownerResolver) {
+ applications.stream()
+ .filter(application -> nonNull(application.getCourtApplicationCases()))
+ .flatMap(application -> application.getCourtApplicationCases().stream())
+ .filter(applicationCase -> nonNull(applicationCase.getOffences()))
+ .forEach(applicationCase -> applicationCase.getOffences().stream()
+ .filter(HearingOffenceFilter::isActive)
+ .filter(offence -> !movedOffenceIds.contains(offence.getId()))//the offences not already in prosecutionCases
+ .forEach(offence -> moveOffenceToProsecution(applicationCase.getProsecutionCaseId(), offence, movedOffenceIds, workingProsecutionCases, ownerResolver)));
+ }
+
+ private static void moveOffenceToProsecution(final UUID prosecutionCaseId,
+ final Offence offence,
+ final Set movedOffenceIds,
+ final List workingProsecutionCases,
+ final OffenceOwnerResolver ownerResolver) {
+ final Optional defendantId = isNull(ownerResolver) ? Optional.empty()
+ : ownerResolver.resolveDefendantIdByOffenceId(prosecutionCaseId, offence.getId());
+
+ if (defendantId.isEmpty()) {
+ LOGGER.warn("Could not resolve owning defendant for active application offence {} in prosecution case {}; leaving it on the application side",
+ offence.getId(), prosecutionCaseId);
+ return;
+ }
+
+ final Optional targetDefendant = workingProsecutionCases.stream()
+ .filter(prosecutionCase -> prosecutionCaseId.equals(prosecutionCase.getId()))
+ .filter(prosecutionCase -> nonNull(prosecutionCase.getDefendants()))
+ .flatMap(prosecutionCase -> prosecutionCase.getDefendants().stream())
+ .filter(defendant -> defendantId.get().equals(defendant.getId()))
+ .findFirst();
+
+ if (targetDefendant.isEmpty()) {
+ LOGGER.warn("Resolved defendant {} for active application offence {} is not present in the hearing's prosecution case {}; leaving it on the application side",
+ defendantId.get(), offence.getId(), prosecutionCaseId);
+ return;
+ }
+
+ // The working prosecution cases are fresh copies built with mutable offence lists, so adding here
+ // never touches the input graph.
+ targetDefendant.get().getOffences().add(offence);
+ movedOffenceIds.add(offence.getId());
+ }
+
+ private static List removeMovedOffencesFromApplications(final List applications, final Set movedOffenceIds) {
+ return applications.stream()
+ .map(application -> CourtApplication.courtApplication()
+ .withValuesFrom(application)
+ .withCourtApplicationCases(removeMovedOffencesFromCases(application.getCourtApplicationCases(), movedOffenceIds))
+ .build())
+ .collect(toList());
+ }
+
+ private static List removeMovedOffencesFromCases(final List applicationCases, final Set movedOffenceIds) {
+ if (isEmpty(applicationCases)) {
+ return applicationCases;
+ }
+ return applicationCases.stream()
+ .map(applicationCase -> {
+ if (isNull(applicationCase.getOffences())) {
+ return applicationCase;
+ }
+ final List remainingOffences = applicationCase.getOffences().stream()
+ .filter(offence -> !movedOffenceIds.contains(offence.getId()))
+ .collect(toList());
+ return CourtApplicationCase.courtApplicationCase()
+ .withValuesFrom(applicationCase)
+ .withOffences(remainingOffences.isEmpty() ? null : remainingOffences)
+ .build();
+ })
+ .collect(toList());
+ }
+
+ private static List dropEmptyDefendantsAndCases(final List prosecutionCases) {
+ return prosecutionCases.stream()
+ .map(prosecutionCase -> ProsecutionCase.prosecutionCase()
+ .withValuesFrom(prosecutionCase)
+ .withDefendants(dropDefendantsWithoutOffences(prosecutionCase.getDefendants()))
+ .build())
+ .filter(prosecutionCase -> isNotEmpty(prosecutionCase.getDefendants()))
+ .collect(toList());
+ }
+
+ private static List dropDefendantsWithoutOffences(final List defendants) {
+ if (isEmpty(defendants)) {
+ return emptyList();
+ }
+ return defendants.stream()
+ .filter(defendant -> isNotEmpty(defendant.getOffences()))
+ .collect(toList());
+ }
+
+ private static Set collectOffenceIds(final List prosecutionCases) {
+ final Set offenceIds = new HashSet<>();
+ prosecutionCases.stream()
+ .filter(prosecutionCase -> nonNull(prosecutionCase.getDefendants()))
+ .flatMap(prosecutionCase -> prosecutionCase.getDefendants().stream())
+ .filter(defendant -> nonNull(defendant.getOffences()))
+ .flatMap(defendant -> defendant.getOffences().stream())
+ .forEach(offence -> offenceIds.add(offence.getId()));
+ return offenceIds;
+ }
+
+ private static boolean isConcluded(final Offence offence) {
+ return isTrue(offence.getProceedingsConcluded());
+ }
+
+ private static boolean isActive(final Offence offence) {
+ return !isConcluded(offence);
+ }
+
+}
diff --git a/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/processor/CourtApplicationProcessorTest.java b/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/processor/CourtApplicationProcessorTest.java
index e1fbefa67..bfc3a63d7 100644
--- a/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/processor/CourtApplicationProcessorTest.java
+++ b/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/processor/CourtApplicationProcessorTest.java
@@ -23,6 +23,7 @@
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.never;
@@ -142,6 +143,7 @@
import com.google.common.io.Resources;
import org.hamcrest.Matchers;
import org.json.JSONException;
+import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
@@ -221,6 +223,15 @@ public static Stream applicationSummonsSpecification() {
);
}
+ @BeforeEach
+ public void stubHearingShapingPassThrough() {
+ // progressionService is mocked here; the application flows now call shapeHearingForListing before
+ // building the hearing commands. These tests verify processor wiring (not the shaping itself, which
+ // is covered by ProgressionServiceTest + HearingOffenceFilterTest), so pass the hearing through unchanged.
+ lenient().when(progressionService.shapeHearingForListing(any(), any()))
+ .thenAnswer(invocation -> invocation.getArgument(0));
+ }
+
@Test
public void processCourtApplicationCreatedWithoutCpsDefendantId() {
//Given
@@ -1339,8 +1350,6 @@ public void shouldProcessEventWhenApplicationReferredToCourtHearing() throws IOE
.add(createObjectBuilder().add("id", OFFENCE_ID_2).add("proceedingsConcluded", false)))
))).build()));
-
-
//When
courtApplicationProcessor.processCourtApplicationReferredToCourtHearing(event);
@@ -1370,6 +1379,38 @@ public void shouldProcessEventWhenApplicationReferredToCourtHearing() throws IOE
verify(progressionService).updateHearingListingStatusToHearingInitiated(any(JsonEnvelope.class), any(Initiate.class));
}
+ @Test
+ public void shouldNotListProsecutionCaseWhenApplicationReferredToCourtHearingHasOnlyConcludedOffences() throws IOException {
+ final UUID applicationId = randomUUID();
+ final MetadataBuilder metadataBuilder = getMetadata("progression.event.application-referred-to-court-hearing");
+
+ final String caseId_1 = randomUUID().toString();
+ final String masterDefendantId1 = randomUUID().toString();
+ // flip the application offence to concluded -> application hearing: the active case must NOT be listed
+ final String inputPayload = Resources.toString(getResource("progression.event.application-referred-to-court-hearing.json"), defaultCharset())
+ .replaceAll("RANDOM_APP_ID", applicationId.toString())
+ .replaceAll("RANDOM_ARN", STRING.next())
+ .replace("CASE_ID_1", caseId_1)
+ .replace("MASTER_DEFENDANT_ID", masterDefendantId1)
+ .replace("\"proceedingsConcluded\": false", "\"proceedingsConcluded\": true");
+
+ final JsonEnvelope event = envelopeFrom(metadataBuilder, stringToJsonObjectConverter.convert(inputPayload));
+
+ //When
+ courtApplicationProcessor.processCourtApplicationReferredToCourtHearing(event);
+
+ //Then - no prosecution case is attached to the hearing, and none leaks into the listing payload
+ final ArgumentCaptor hearingCaptor = forClass(Hearing.class);
+ verify(progressionService).linkApplicationToHearing(any(JsonEnvelope.class), hearingCaptor.capture(), eq(HearingListingStatus.HEARING_INITIALISED));
+ assertThat(hearingCaptor.getValue().getProsecutionCases(), Matchers.nullValue());
+
+ final ArgumentCaptor listCaptor = forClass(ListCourtHearing.class);
+ verify(listingService).listCourtHearing(any(), listCaptor.capture());
+ // the listing payload carries no prosecution case to list (the application's courtApplicationCase
+ // reference may still hold the caseId, but the case must not appear under hearings[].prosecutionCases)
+ assertThat(objectToJsonObjectConverter.convert(listCaptor.getValue()).toString(), isJson(withoutJsonPath("$.hearings[0].prosecutionCases")));
+ }
+
@Test
public void shouldProcessEventWhenApplicationReferredToExistingHearing() {
final Function enveloperFunction = mock(Function.class);
@@ -2569,6 +2610,84 @@ private CustomComparator getCustomComparator() {
);
}
+ @Test
+ public void isActiveCaseByOffenceStatusShouldReturnFalseWhenAllOffencesConcluded() {
+ final CourtApplicationCase courtApplicationCase = courtApplicationCase()
+ .withCaseStatus("ACTIVE")
+ .withOffences(List.of(
+ Offence.offence().withProceedingsConcluded(true).build(),
+ Offence.offence().withProceedingsConcluded(true).build()))
+ .build();
+
+ assertThat(courtApplicationProcessor.isActiveCaseByOffenceStatus(courtApplicationCase), is(false));
+ }
+
+ @Test
+ public void isActiveCaseByOffenceStatusShouldReturnTrueWhenAnyOffenceNotConcluded() {
+ final CourtApplicationCase courtApplicationCase = courtApplicationCase()
+ .withCaseStatus("INACTIVE")
+ .withOffences(List.of(
+ Offence.offence().withProceedingsConcluded(true).build(),
+ Offence.offence().withProceedingsConcluded(false).build()))
+ .build();
+
+ assertThat(courtApplicationProcessor.isActiveCaseByOffenceStatus(courtApplicationCase), is(true));
+ }
+
+ @Test
+ public void isActiveCaseByOffenceStatusShouldTreatNullProceedingsConcludedAsActive() {
+ final CourtApplicationCase courtApplicationCase = courtApplicationCase()
+ .withCaseStatus("INACTIVE")
+ .withOffences(singletonList(Offence.offence().build()))
+ .build();
+
+ assertThat(courtApplicationProcessor.isActiveCaseByOffenceStatus(courtApplicationCase), is(true));
+ }
+
+ @Test
+ public void isActiveCaseByOffenceStatusShouldFallBackToActiveCaseStatusWhenNoOffences() {
+ final CourtApplicationCase courtApplicationCase = courtApplicationCase()
+ .withCaseStatus("ACTIVE")
+ .build();
+
+ assertThat(courtApplicationProcessor.isActiveCaseByOffenceStatus(courtApplicationCase), is(true));
+ }
+
+ @Test
+ public void isActiveCaseByOffenceStatusShouldFallBackToInactiveCaseStatusWhenNoOffences() {
+ final CourtApplicationCase courtApplicationCase = courtApplicationCase()
+ .withCaseStatus("INACTIVE")
+ .build();
+
+ assertThat(courtApplicationProcessor.isActiveCaseByOffenceStatus(courtApplicationCase), is(false));
+ }
+
+ @Test
+ public void isActiveCaseByOffenceStatusShouldFallBackToClosedCaseStatusWhenNoOffences() {
+ final CourtApplicationCase courtApplicationCase = courtApplicationCase()
+ .withCaseStatus("CLOSED")
+ .build();
+
+ assertThat(courtApplicationProcessor.isActiveCaseByOffenceStatus(courtApplicationCase), is(false));
+ }
+
+ @Test
+ public void isActiveCaseByOffenceStatusShouldFallBackToCaseStatusWhenOffencesEmpty() {
+ final CourtApplicationCase courtApplicationCase = courtApplicationCase()
+ .withCaseStatus("ACTIVE")
+ .withOffences(List.of())
+ .build();
+
+ assertThat(courtApplicationProcessor.isActiveCaseByOffenceStatus(courtApplicationCase), is(true));
+ }
+
+ @Test
+ public void isActiveCaseByOffenceStatusShouldReturnTrueWhenNoOffencesAndCaseStatusNull() {
+ final CourtApplicationCase courtApplicationCase = courtApplicationCase().build();
+
+ assertThat(courtApplicationProcessor.isActiveCaseByOffenceStatus(courtApplicationCase), is(true));
+ }
+
private MetadataBuilder getMetadata(final String eventName) {
return metadataBuilder()
.withId(randomUUID())
diff --git a/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/processor/HearingConfirmedEventProcessorTest.java b/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/processor/HearingConfirmedEventProcessorTest.java
index da3bef707..364ea6999 100644
--- a/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/processor/HearingConfirmedEventProcessorTest.java
+++ b/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/processor/HearingConfirmedEventProcessorTest.java
@@ -243,7 +243,7 @@ public void shouldHandleHearingConfirmedWithCasesEventMessage() throws Exception
when(jsonObjectToObjectConverter.convert(envelope.payloadAsJsonObject(), HearingConfirmed.class)).thenReturn(hearingConfirmed);
doNothing().when(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
when(enveloperFunction.apply(any())).thenReturn(finalEnvelope);
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(randomUUID())
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now()).build()))
@@ -312,7 +312,7 @@ public void shouldHandleHearingConfirmedWithCasesEventMessage_SendOnlinePleaWhen
final JsonObject sampleJsonObject2 = createObjectBuilder().add("isWelsh", false).build();
when(referenceDataService.getCourtCentreWithCourtRoomsById(courtCentreId, envelope, requester)).thenReturn(Optional.of(sampleJsonObject2));
when(calendarService.plusWorkingDays(LocalDate.now(), 11L, requester)).thenReturn(LocalDate.now().plusDays(60));
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(randomUUID())
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now().plusDays(40)).build()))
@@ -385,7 +385,7 @@ public void shouldHandleHearingConfirmedWithCasesEventMessage_DoNotSendOnlinePle
doNothing().when(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
when(enveloperFunction.apply(any())).thenReturn(finalEnvelope);
when(featureControlGuard.isFeatureEnabled("OPA")).thenReturn(false);
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(randomUUID())
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now()).build()))
@@ -441,7 +441,7 @@ public void shouldHandleHearingConfirmedWithCasesEventMessageAndForBulkCaseDoesN
when(envelope.payloadAsJsonObject()).thenReturn(payload);
when(jsonObjectToObjectConverter.convert(envelope.payloadAsJsonObject(), HearingConfirmed.class)).thenReturn(hearingConfirmed);
when(enveloperFunction.apply(any())).thenReturn(finalEnvelope);
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(randomUUID())
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now()).build()))
@@ -512,7 +512,7 @@ public void shouldHandleHearingConfirmedWithCasesEventMessageWhenPartialHearingC
doNothing().when(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
when(partialHearingConfirmService.getDifferences(confirmedHearing, hearing)).thenReturn(deltaProsecutionCases);
when(enveloperFunction.apply(any(JsonObject.class))).thenReturn(finalEnvelope);
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(hearing);
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(hearing);
when(enveloper.withMetadataFrom(envelope, "progression.command-enrich-hearing-initiate")).thenReturn(enveloperFunction);
when(enveloper.withMetadataFrom(envelope, "progression.command-link-prosecution-cases-to-hearing")).thenReturn(enveloperFunction);
when(enveloper.withMetadataFrom(envelope, "progression.command.assign-defendant-request-from-current-hearing-to-extend-hearing")).thenReturn(enveloperFunction);
@@ -619,7 +619,7 @@ public void shouldHandleHearingConfirmedWithCasesEventMessageWhenPartialHearingC
when(partialHearingConfirmService.transformToUpdateHearingForPartialAllocation(hearingId, deltaProsecutionCases)).thenReturn(updateHearingForPartialAllocation);
when(partialHearingConfirmService.transformToListNextCourtHearing(any(), any(), any(), eq(seedingHearing))).thenReturn(listNextHearings);
when(enveloperFunction.apply(any())).thenReturn(finalEnvelope);
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(hearing);
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(hearing);
when(enveloper.withMetadataFrom(envelope, "progression.command-enrich-hearing-initiate")).thenReturn(enveloperFunction);
when(enveloper.withMetadataFrom(envelope, "progression.command-link-prosecution-cases-to-hearing")).thenReturn(enveloperFunction);
when(enveloper.withMetadataFrom(envelope, "progression.command.assign-defendant-request-from-current-hearing-to-extend-hearing")).thenReturn(enveloperFunction);
@@ -807,7 +807,7 @@ void shouldProcessHearingConfirmedReplayedAndConfirmHearing() {
when(jsonObjectToObjectConverter.convert(payload, HearingConfirmedReplayed.class)).thenReturn(hearingConfirmedReplayed);
doNothing().when(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
when(enveloperFunction.apply(any())).thenReturn(finalEnvelope);
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(hearingId)
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now()).build()))
@@ -825,7 +825,7 @@ void shouldProcessHearingConfirmedReplayedAndConfirmHearing() {
eventProcessor.processHearingConfirmedReplayed(envelope);
verify(jsonObjectToObjectConverter).convert(payload, HearingConfirmedReplayed.class);
- verify(progressionService).transformConfirmedHearing(any(), eq(envelope), any());
+ verify(progressionService).transformConfirmedHearing(any(), eq(envelope), any(), any());
verify(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
verify(sender, times(2)).send(any());
}
@@ -969,7 +969,7 @@ public void shouldHandleHearingConfirmedWithApplicationsEventMessage() {
when(hearingConfirmed.getConfirmedHearing()).thenReturn(confirmedHearing);
doNothing().when(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
when(enveloperFunction.apply(any(JsonObject.class))).thenReturn(finalEnvelope);
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(hearing);
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(hearing);
doNothing().when(progressionService).updateCourtApplicationStatus(any(), any(), anyList(), any());
when(enveloper.withMetadataFrom(envelope, "progression.command-enrich-hearing-initiate")).thenReturn(enveloperFunction);
when(envelope.payloadAsJsonObject()).thenReturn(payload);
@@ -1028,7 +1028,7 @@ public void shouldHandleHearingConfirmedWithCaseAndApplicationsEventMessage() {
doNothing().when(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
when(enveloperFunction.apply(any())).thenReturn(finalEnvelope);
- when(progressionService.transformConfirmedHearing(confirmedHearing, envelope, seedingHearing)).thenReturn(hearing);
+ when(progressionService.transformConfirmedHearing(confirmedHearing, envelope, seedingHearing, hearing)).thenReturn(hearing);
when(enveloper.withMetadataFrom(any(), any())).thenReturn(enveloperFunction);
when(progressionService.retrieveHearing(envelope, hearingId)).thenReturn(hearing);
@@ -1068,7 +1068,7 @@ public void shouldCallInitiateHearing() throws Exception {
when(enveloper.withMetadataFrom(envelope, "hearing.initiate")).thenReturn(enveloperFunction);
when(enveloper.withMetadataFrom(envelope, HearingConfirmedEventProcessor.PUBLIC_PROGRESSION_EVENT_PROSECUTION_CASES_REFERRED_TO_COURT))
.thenReturn(enveloperFunction);
-
+ when(progressionService.shapeExistingHearingForListing(any(), any())).thenReturn(arbitraryInitiateObj.getHearing());
eventProcessor.processHearingInitiatedEnrichedEvent(envelope);
//Then
@@ -1144,7 +1144,7 @@ public void shouldHandleHearingConfirmed_NotificationSendTrue() {
doNothing().when(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
when(enveloperFunction.apply(any())).thenReturn(finalEnvelope);
when(applicationParameters.getNotifyHearingTemplateId()).thenReturn(("e4648583-eb0f-438e-aab5-5eff29f3f7b4"));
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(randomUUID())
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now()).build()))
@@ -1226,7 +1226,7 @@ public void shouldHandleHearingConfirmedforAutApplication_NotificationSendTrue()
doNothing().when(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
when(enveloperFunction.apply(any(JsonObject.class))).thenReturn(finalEnvelope);
when(applicationParameters.getNotifyHearingTemplateId()).thenReturn(("e4648583-eb0f-438e-aab5-5eff29f3f7b4"));
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(randomUUID())
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now()).build()))
@@ -1357,7 +1357,7 @@ public void shouldHandleHearingConfirmedForApplication_NotificationSendTrue() {
doNothing().when(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
when(enveloperFunction.apply(any())).thenReturn(finalEnvelope);
when(applicationParameters.getNotifyHearingTemplateId()).thenReturn(("e4648583-eb0f-438e-aab5-5eff29f3f7b4"));
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(hearingId)
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now()).build()))
@@ -1419,7 +1419,7 @@ public void shouldHandleHearingConfirmed_NotificationSendFalse() {
doNothing().when(progressionService).prepareSummonsData(any(JsonEnvelope.class), any(ConfirmedHearing.class));
when(enveloperFunction.apply(any())).thenReturn(finalEnvelope);
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(randomUUID())
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now()).build()))
@@ -1549,6 +1549,7 @@ public void shouldCallInitiateHearingWhenProsecutionCasesNotPresent() throws Exc
//When
when(jsonObjectToObjectConverter.convert(envelope.payloadAsJsonObject(), Initiate.class))
.thenReturn(arbitraryInitiateObj);
+ when(progressionService.shapeExistingHearingForListing(any(), any())).thenReturn(arbitraryInitiateObj.getHearing());
when(enveloperFunction.apply(any(JsonObject.class))).thenReturn(finalEnvelope);
@@ -1582,7 +1583,7 @@ public void shouldNotSendPostalNotificationForStandaloneApplicationsWithHearingT
when(hearingConfirmed.getConfirmedHearing()).thenReturn(confirmedHearing);
when(envelope.payloadAsJsonObject()).thenReturn(payload);
when(jsonObjectToObjectConverter.convert(envelope.payloadAsJsonObject(), HearingConfirmed.class)).thenReturn(hearingConfirmed);
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(randomUUID())
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now()).build()))
@@ -1619,7 +1620,7 @@ public void shouldNotSendPostalNotificationForStandaloneApplicationsWithHearingT
when(hearingConfirmed.getConfirmedHearing()).thenReturn(confirmedHearing);
when(envelope.payloadAsJsonObject()).thenReturn(payload);
when(jsonObjectToObjectConverter.convert(envelope.payloadAsJsonObject(), HearingConfirmed.class)).thenReturn(hearingConfirmed);
- when(progressionService.transformConfirmedHearing(any(), any(), any())).thenReturn(
+ when(progressionService.transformConfirmedHearing(any(), any(), any(), any())).thenReturn(
Hearing.hearing()
.withId(randomUUID())
.withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(new UtcClock().now()).build()))
diff --git a/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/service/ProgressionServiceTest.java b/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/service/ProgressionServiceTest.java
index 840207a96..062fdd1e4 100644
--- a/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/service/ProgressionServiceTest.java
+++ b/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/service/ProgressionServiceTest.java
@@ -20,9 +20,11 @@
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.sameInstance;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@@ -123,6 +125,7 @@
import uk.gov.justice.services.messaging.JsonEnvelope;
import uk.gov.moj.cpp.progression.exception.DataValidationException;
import uk.gov.moj.cpp.progression.processor.exceptions.CourtApplicationAndCaseNotFoundException;
+import uk.gov.moj.cpp.progression.transformer.HearingOffenceFilter;
import java.io.IOException;
import java.io.StringReader;
@@ -1481,6 +1484,297 @@ public void shouldTransformCourtCentre1() {
assertThat(hearing.getCourtCentre().getLja().getWelshLjaName(), is("welshName"));
}
+ @Test
+ public void transformConfirmedHearingShouldKeepConfirmedCaseOffencesWhenAllApplicationOffencesConcluded() {
+ final UUID courtCentreId = randomUUID();
+ final UUID caseId = fromString("63d5739e-4aa3-4d53-ae3b-4f16b2ce6c95");
+ final UUID defendantId = fromString("96ec1814-cfcd-4ef4-ba18-315a6c48659f");
+ final UUID matchedOffenceId = fromString("ca438f25-e9a4-4a6b-a26d-467674755171");
+ final UUID applicationId = randomUUID();
+ final UUID concludedApplicationOffenceId = randomUUID();
+
+ mockCourtCentre(courtCentreId);
+ mockProsecutionCaseLookup();
+ mockCourtApplicationLookup(courtApplication().withId(applicationId)
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withProsecutionCaseId(caseId)
+ .withOffences(singletonList(Offence.offence().withId(concludedApplicationOffenceId).withProceedingsConcluded(true).build()))
+ .build()))
+ .build());
+
+ final ConfirmedHearing confirmedHearing = confirmedHearingWith(courtCentreId, caseId, defendantId, matchedOffenceId, applicationId);
+
+ final Hearing hearing = progressionService.transformConfirmedHearing(confirmedHearing, finalEnvelope);
+
+ // the confirmed hearing pre-exists and its listed case offence is unrelated to the application, so
+ // even though all application offences are concluded the prosecution side must be preserved
+ // (adjourn/next-hearing regression: previously wiped, losing the adjourned offences)
+ assertThat(hearing.getProsecutionCases().size(), is(1));
+ assertThat(hearing.getProsecutionCases().get(0).getId(), is(caseId));
+ assertThat(hearing.getProsecutionCases().get(0).getDefendants().get(0).getOffences().size(), is(1));
+ assertThat(hearing.getProsecutionCases().get(0).getDefendants().get(0).getOffences().get(0).getId(), is(matchedOffenceId));
+ // the concluded offence stays under the application
+ assertThat(hearing.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences().size(), is(1));
+ assertThat(hearing.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences().get(0).getId(), is(concludedApplicationOffenceId));
+ }
+
+ @Test
+ public void transformConfirmedHearingShouldMoveActiveApplicationOffenceToProsecutionAndClearItFromApplication() {
+ final UUID courtCentreId = randomUUID();
+ final UUID caseId = fromString("63d5739e-4aa3-4d53-ae3b-4f16b2ce6c95");
+ final UUID defendantId = fromString("96ec1814-cfcd-4ef4-ba18-315a6c48659f");
+ final UUID sharedOffenceId = fromString("ca438f25-e9a4-4a6b-a26d-467674755171");
+ final UUID applicationId = randomUUID();
+
+ mockCourtCentre(courtCentreId);
+ mockProsecutionCaseLookup();
+ mockCourtApplicationLookup(courtApplication().withId(applicationId)
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withProsecutionCaseId(caseId)
+ .withOffences(singletonList(Offence.offence().withId(sharedOffenceId).withProceedingsConcluded(false).build()))
+ .build()))
+ .build());
+
+ final ConfirmedHearing confirmedHearing = confirmedHearingWith(courtCentreId, caseId, defendantId, sharedOffenceId, applicationId);
+
+ final Hearing hearing = progressionService.transformConfirmedHearing(confirmedHearing, finalEnvelope);
+
+ // active application offence kept once under prosecution and removed from the application case
+ assertThat(hearing.getProsecutionCases().get(0).getDefendants().get(0).getOffences().size(), is(1));
+ assertThat(hearing.getProsecutionCases().get(0).getDefendants().get(0).getOffences().get(0).getId(), is(sharedOffenceId));
+ assertThat(hearing.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences(), is(nullValue()));
+ }
+
+ @Test
+ public void offenceOwnerResolverShouldFetchEachProsecutionCaseOnlyOncePerCall() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID offence1 = randomUUID();
+ final UUID offence2 = randomUUID();
+
+ final ProsecutionCase prosecutionCase = ProsecutionCase.prosecutionCase()
+ .withId(caseId)
+ .withDefendants(singletonList(Defendant.defendant().withId(defendantId)
+ .withOffences(asList(
+ Offence.offence().withId(offence1).build(),
+ Offence.offence().withId(offence2).build()))
+ .build()))
+ .build();
+ final JsonObject responsePayload = createObjectBuilder()
+ .add("prosecutionCase", objectToJsonObjectConverter.convert(prosecutionCase))
+ .build();
+
+ final Function prosecutionCaseFn = mock(Function.class);
+ final JsonEnvelope prosecutionCaseRequest = mock(JsonEnvelope.class);
+ final JsonEnvelope prosecutionCaseResponse = mock(JsonEnvelope.class);
+ when(enveloper.withMetadataFrom(finalEnvelope, "progression.query.prosecutioncase-v2")).thenReturn(prosecutionCaseFn);
+ when(prosecutionCaseFn.apply(any())).thenReturn(prosecutionCaseRequest);
+ when(prosecutionCaseResponse.payloadAsJsonObject()).thenReturn(responsePayload);
+ when(requester.requestAsAdmin(prosecutionCaseRequest)).thenReturn(prosecutionCaseResponse);
+
+ final HearingOffenceFilter.OffenceOwnerResolver resolver = progressionService.offenceOwnerResolver(finalEnvelope);
+
+ // two offences belonging to the same case are both resolved to the owning defendant...
+ assertThat(resolver.resolveDefendantIdByOffenceId(caseId, offence1).orElse(null), is(defendantId));
+ assertThat(resolver.resolveDefendantIdByOffenceId(caseId, offence2).orElse(null), is(defendantId));
+
+ // ...but the prosecution case is fetched from the API only once
+ verify(requester, times(1)).requestAsAdmin(prosecutionCaseRequest);
+ }
+
+ @Test
+ public void shapeHearingForListingShouldDropProsecutionCasesForApplicationHearing() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID activeCaseOffenceId = randomUUID();
+ final UUID concludedApplicationOffenceId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withProsecutionCases(singletonList(ProsecutionCase.prosecutionCase()
+ .withId(caseId)
+ .withDefendants(singletonList(Defendant.defendant().withId(defendantId)
+ .withOffences(singletonList(Offence.offence().withId(activeCaseOffenceId).build()))
+ .build()))
+ .build()))
+ .withCourtApplications(singletonList(courtApplication()
+ .withCourtApplicationCases(singletonList(courtApplicationCase()
+ .withProsecutionCaseId(caseId)
+ .withOffences(singletonList(Offence.offence().withId(concludedApplicationOffenceId).withProceedingsConcluded(true).build()))
+ .build()))
+ .build()))
+ .build();
+
+ final Hearing shaped = progressionService.shapeHearingForListing(hearing, finalEnvelope);
+
+ // all application offences concluded -> application hearing: prosecution side dropped, application offence kept
+ assertThat(shaped.getProsecutionCases(), is(nullValue()));
+ assertThat(shaped.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences().get(0).getId(), is(concludedApplicationOffenceId));
+ }
+
+ @Test
+ public void shapeHearingForListingShouldLeaveCaseOnlyHearingUnchanged() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID offenceId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withProsecutionCases(singletonList(ProsecutionCase.prosecutionCase()
+ .withId(caseId)
+ .withDefendants(singletonList(Defendant.defendant().withId(defendantId)
+ .withOffences(singletonList(Offence.offence().withId(offenceId).build()))
+ .build()))
+ .build()))
+ .build();
+
+ final Hearing shaped = progressionService.shapeHearingForListing(hearing, finalEnvelope);
+
+ // no court applications -> not an application hearing: prosecution cases untouched
+ assertThat(shaped.getProsecutionCases().size(), is(1));
+ assertThat(shaped.getProsecutionCases().get(0).getDefendants().get(0).getOffences().get(0).getId(), is(offenceId));
+ }
+
+ // ---- CHD-2687: prosecution-case order anchored on progression's stored hearing ------------
+
+ @Test
+ public void reorderShouldPutExistingHearingCasesFirstKeepingStoredRelativeOrder() {
+ final UUID case1 = randomUUID();
+ final UUID case2 = randomUUID();
+ final UUID case3 = randomUUID();
+
+ // progression already knows the hearing as [case2, case3]; the confirmed payload arrives
+ // with the incoming case first (adjournment onto an existing hearing)
+ final Hearing anchor = hearingWithCases(case2, case3);
+ final Hearing shaped = hearingWithCases(case3, case1, case2);
+
+ final Hearing reordered = progressionService.reorderProsecutionCasesByExistingHearing(shaped, anchor);
+
+ assertThat(reordered.getProsecutionCases().get(0).getId(), is(case2));
+ assertThat(reordered.getProsecutionCases().get(1).getId(), is(case3));
+ assertThat(reordered.getProsecutionCases().get(2).getId(), is(case1));
+ }
+
+ @Test
+ public void reorderShouldHandleTheAdjournOntoExistingLinkedCaseHearingShape() {
+ // CHD-2687 AC3: hearing of case2 extended by adjourning case1 + application; payload came
+ // in as [case1, case2] and displayed in that order - existing case must stay first
+ final UUID case1 = randomUUID();
+ final UUID case2 = randomUUID();
+
+ final Hearing reordered = progressionService.reorderProsecutionCasesByExistingHearing(
+ hearingWithCases(case1, case2), hearingWithCases(case2));
+
+ assertThat(reordered.getProsecutionCases().get(0).getId(), is(case2));
+ assertThat(reordered.getProsecutionCases().get(1).getId(), is(case1));
+ }
+
+ @Test
+ public void reorderShouldReturnHearingUnchangedWithoutAnchor() {
+ final Hearing shaped = hearingWithCases(randomUUID(), randomUUID());
+
+ assertThat(progressionService.reorderProsecutionCasesByExistingHearing(shaped, null), sameInstance(shaped));
+ assertThat(progressionService.reorderProsecutionCasesByExistingHearing(shaped, Hearing.hearing().withId(randomUUID()).build()), sameInstance(shaped));
+ }
+
+ @Test
+ public void reorderShouldReturnHearingUnchangedWhenNoAnchoredCasePresent() {
+ // fresh content only (e.g. hearing just created): nothing to anchor, order untouched
+ final Hearing shaped = hearingWithCases(randomUUID());
+ final Hearing anchor = hearingWithCases(randomUUID());
+
+ assertThat(progressionService.reorderProsecutionCasesByExistingHearing(shaped, anchor), sameInstance(shaped));
+ }
+
+ private static Hearing hearingWithCases(final UUID... caseIds) {
+ return Hearing.hearing()
+ .withId(randomUUID())
+ .withProsecutionCases(java.util.Arrays.stream(caseIds)
+ .map(id -> ProsecutionCase.prosecutionCase().withId(id).build())
+ .collect(java.util.stream.Collectors.toList()))
+ .build();
+ }
+
+ @Test
+ public void updateHearingListingStatusToHearingInitiatedShouldSendHearingInitialisedCommand() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID offenceId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withProsecutionCases(singletonList(ProsecutionCase.prosecutionCase()
+ .withId(caseId)
+ .withDefendants(singletonList(Defendant.defendant().withId(defendantId)
+ .withOffences(singletonList(Offence.offence().withId(offenceId).build()))
+ .build()))
+ .build()))
+ .build();
+
+ final Function commandFn = mock(Function.class);
+ when(enveloper.withMetadataFrom(finalEnvelope, PROGRESSION_UPDATE_DEFENDANT_LISTING_STATUS_COMMAND)).thenReturn(commandFn);
+ when(commandFn.apply(any())).thenReturn(mock(JsonEnvelope.class));
+
+ progressionService.updateHearingListingStatusToHearingInitiated(finalEnvelope, Initiate.initiate().withHearing(hearing).build());
+
+ final ArgumentCaptor commandCaptor = ArgumentCaptor.forClass(JsonObject.class);
+ verify(commandFn).apply(commandCaptor.capture());
+ final JsonObject command = commandCaptor.getValue();
+ assertThat(command.getString("hearingListingStatus"), is("HEARING_INITIALISED"));
+
+ // the method serialises the hearing as-is; shaping happens upstream now, not here
+ final Hearing sentHearing = jsonObjectConverter.convert(command.getJsonObject("hearing"), Hearing.class);
+ assertThat(sentHearing.getProsecutionCases().size(), is(1));
+ assertThat(sentHearing.getProsecutionCases().get(0).getDefendants().get(0).getOffences().get(0).getId(), is(offenceId));
+ }
+
+ private void mockCourtCentre(final UUID courtCentreId) {
+ final JsonObject courtCentreJson = createObjectBuilder().add("oucodeL3Name", "Lavender Hill Magistrates Court").add("address1", "ADDRESS1").add("oucode", "OU").add("lja", "ljaCode").build();
+ when(referenceDataService.getOrganisationUnitById(courtCentreId, finalEnvelope, requester)).thenReturn(of(courtCentreJson));
+ when(referenceDataService.getLjaDetails(any(), any(), any())).thenReturn(LjaDetails.ljaDetails().withLjaCode("nationalCourtCode").withLjaName("name").withWelshLjaName("welshName").build());
+ }
+
+ private void mockProsecutionCaseLookup() {
+ final Function prosecutionCaseFn = mock(Function.class);
+ final JsonEnvelope prosecutionCaseRequest = mock(JsonEnvelope.class);
+ final JsonEnvelope prosecutionCaseResponse = mock(JsonEnvelope.class);
+ when(enveloper.withMetadataFrom(finalEnvelope, "progression.query.prosecutioncase-v2")).thenReturn(prosecutionCaseFn);
+ when(prosecutionCaseFn.apply(any())).thenReturn(prosecutionCaseRequest);
+ when(prosecutionCaseResponse.payloadAsJsonObject()).thenReturn(getPayload("caseQueryApiWithCourtOrdersExpectedResponse.json"));
+ when(requester.requestAsAdmin(prosecutionCaseRequest)).thenReturn(prosecutionCaseResponse);
+ }
+
+ private void mockCourtApplicationLookup(final CourtApplication application) {
+ // Build the payload up front: invoking the spy converter inside a when(...).thenReturn(...)
+ // argument would trip Mockito's UnfinishedStubbingException.
+ final JsonObject applicationPayload = createObjectBuilder()
+ .add("courtApplication", objectToJsonObjectConverter.convert(application))
+ .build();
+ final Function applicationFn = mock(Function.class);
+ final JsonEnvelope applicationRequest = mock(JsonEnvelope.class);
+ final JsonEnvelope applicationResponse = mock(JsonEnvelope.class);
+ when(enveloper.withMetadataFrom(finalEnvelope, "progression.query.application-only")).thenReturn(applicationFn);
+ when(applicationFn.apply(any())).thenReturn(applicationRequest);
+ when(applicationResponse.payloadAsJsonObject()).thenReturn(applicationPayload);
+ when(requester.requestAsAdmin(applicationRequest)).thenReturn(applicationResponse);
+ }
+
+ private ConfirmedHearing confirmedHearingWith(final UUID courtCentreId, final UUID caseId, final UUID defendantId, final UUID offenceId, final UUID applicationId) {
+ return ConfirmedHearing.confirmedHearing()
+ .withId(randomUUID())
+ .withHearingDays(singletonList(HearingDay.hearingDay().withSittingDay(ZonedDateTime.now()).build()))
+ .withCourtCentre(CourtCentre.courtCentre().withId(courtCentreId).build())
+ .withCourtApplicationIds(singletonList(applicationId))
+ .withProsecutionCases(singletonList(ConfirmedProsecutionCase.confirmedProsecutionCase()
+ .withId(caseId)
+ .withDefendants(singletonList(ConfirmedDefendant.confirmedDefendant()
+ .withId(defendantId)
+ .withOffences(singletonList(ConfirmedOffence.confirmedOffence().withId(offenceId).build()))
+ .build()))
+ .build()))
+ .build();
+ }
+
@Test
public void shouldCreateNextHearingAndUpdateHearingListingStatusToSentForListingOnNextHearingRequested() {
final JsonEnvelope jsonEnvelope = getEnvelope(PROGRESSION_EVENT_NEXT_HEARINGS_REQUESTED);
diff --git a/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/transformer/HearingOffenceFilterTest.java b/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/transformer/HearingOffenceFilterTest.java
new file mode 100644
index 000000000..91b10e789
--- /dev/null
+++ b/progression-event/progression-event-processor/src/test/java/uk/gov/moj/cpp/progression/transformer/HearingOffenceFilterTest.java
@@ -0,0 +1,695 @@
+package uk.gov.moj.cpp.progression.transformer;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static java.util.UUID.randomUUID;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.Matchers.sameInstance;
+
+import uk.gov.justice.core.courts.CourtApplication;
+import uk.gov.justice.core.courts.CourtApplicationCase;
+import uk.gov.justice.core.courts.CourtOrder;
+import uk.gov.justice.core.courts.CourtOrderOffence;
+import uk.gov.justice.core.courts.Defendant;
+import uk.gov.justice.core.courts.Hearing;
+import uk.gov.justice.core.courts.Offence;
+import uk.gov.justice.core.courts.ProsecutionCase;
+import uk.gov.moj.cpp.progression.transformer.HearingOffenceFilter.OffenceOwnerResolver;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.Test;
+
+class HearingOffenceFilterTest {
+
+ private static final OffenceOwnerResolver NO_OWNER = (caseId, offenceId) -> Optional.empty();
+
+ // ---- Guards -------------------------------------------------------------
+
+ @Test
+ void shouldReturnNullWhenHearingIsNull() {
+ assertThat(HearingOffenceFilter.filterOffences(null, NO_OWNER), is(nullValue()));
+ }
+
+ @Test
+ void shouldReturnSameHearingWhenNoCourtApplications() {
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withProsecutionCases(singletonList(prosecutionCase(randomUUID(), defendant(randomUUID(), activeOffence(randomUUID())))))
+ .build();
+
+ assertThat(HearingOffenceFilter.filterOffences(hearing, NO_OWNER), is(sameInstance(hearing)));
+ }
+
+ @Test
+ void shouldReturnSameHearingWhenApplicationsHaveNoOffences() {
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(CourtApplication.courtApplication()
+ .withId(randomUUID())
+ .withCourtApplicationCases(singletonList(CourtApplicationCase.courtApplicationCase()
+ .withProsecutionCaseId(randomUUID())
+ .build()))
+ .build()))
+ .build();
+
+ assertThat(HearingOffenceFilter.filterOffences(hearing, NO_OWNER), is(sameInstance(hearing)));
+ }
+
+ // ---- Branch 1: application hearing (all application offences concluded) --
+
+ @Test
+ void shouldDropProsecutionCasesWhenAllApplicationOffencesConcluded() {
+ final UUID caseId = randomUUID();
+ final Offence concluded1 = concludedOffence(randomUUID());
+ final Offence concluded2 = concludedOffence(randomUUID());
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, concluded1, concluded2)))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId, defendant(randomUUID(), activeOffence(randomUUID())))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ assertThat(result.getProsecutionCases(), is(nullValue()));
+ // application offences are left untouched
+ assertThat(offenceIds(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences()),
+ containsInAnyOrder(concluded1.getId(), concluded2.getId()));
+ }
+
+ // ---- Branch 2: active application offences move to prosecution ----------
+
+ @Test
+ void shouldKeepActiveOffenceUnderProsecutionAndRemoveItFromApplication() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID sharedOffenceId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, activeOffence(sharedOffenceId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId, defendant(defendantId, activeOffence(sharedOffenceId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ // offence stays once under prosecution
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()), contains(sharedOffenceId));
+ // and is removed from the application case (only offence -> list nulled)
+ assertThat(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences(), is(nullValue()));
+ }
+
+ @Test
+ void shouldKeepConcludedApplicationOffenceAndMoveOnlyTheActiveOne() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID activeId = randomUUID();
+ final UUID concludedId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, activeOffence(activeId), concludedOffence(concludedId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId, defendant(defendantId, activeOffence(activeId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ // active offence kept under prosecution
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()), contains(activeId));
+ // concluded offence remains on the application side; active one removed
+ assertThat(offenceIds(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences()), contains(concludedId));
+ }
+
+ @Test
+ void shouldRemoveProsecutionOffencesNotReferencedByApplication() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID referencedId = randomUUID();
+ final UUID unreferencedId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, activeOffence(referencedId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId,
+ defendant(defendantId, activeOffence(referencedId), activeOffence(unreferencedId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()), contains(referencedId));
+ }
+
+ @Test
+ void shouldDropDefendantsAndCasesLeftEmptyAfterCleanup() {
+ final UUID caseId = randomUUID();
+ final UUID keptDefendantId = randomUUID();
+ final UUID emptiedDefendantId = randomUUID();
+ final UUID referencedId = randomUUID();
+ final UUID unreferencedId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, activeOffence(referencedId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId,
+ defendant(keptDefendantId, activeOffence(referencedId)),
+ defendant(emptiedDefendantId, activeOffence(unreferencedId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ assertThat(result.getProsecutionCases().get(0).getDefendants(), hasSize(1));
+ assertThat(result.getProsecutionCases().get(0).getDefendants().get(0).getId(), is(keptDefendantId));
+ }
+
+ @Test
+ void shouldNullProsecutionCasesWhenCleanupRemovesEverything() {
+ // active application offence references nothing present in prosecution, and the resolver cannot place it
+ final UUID caseId = randomUUID();
+ final UUID appOnlyActiveId = randomUUID();
+ final UUID prosecutionOnlyId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, activeOffence(appOnlyActiveId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId, defendant(randomUUID(), activeOffence(prosecutionOnlyId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ assertThat(result.getProsecutionCases(), is(nullValue()));
+ // unresolved active offence is left on the application side (warn + leave)
+ assertThat(offenceIds(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences()), contains(appOnlyActiveId));
+ }
+
+ // ---- Move-add fallback via resolver -------------------------------------
+
+ @Test
+ void shouldMoveActiveOffenceToResolvedDefendantWhenAbsentFromProsecution() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID presentActiveId = randomUUID();
+ final UUID absentActiveId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, activeOffence(presentActiveId), activeOffence(absentActiveId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId, defendant(defendantId, activeOffence(presentActiveId)))))
+ .build();
+
+ final OffenceOwnerResolver resolver = (resolveCaseId, offenceId) ->
+ absentActiveId.equals(offenceId) ? Optional.of(defendantId) : Optional.empty();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, resolver);
+
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()),
+ containsInAnyOrder(presentActiveId, absentActiveId));
+ // both active offences moved off the application
+ assertThat(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences(), is(nullValue()));
+ }
+
+ @Test
+ void shouldLeaveActiveOffenceOnApplicationWhenResolvedDefendantNotInHearing() {
+ final UUID caseId = randomUUID();
+ final UUID presentActiveId = randomUUID();
+ final UUID absentActiveId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, activeOffence(presentActiveId), activeOffence(absentActiveId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId, defendant(randomUUID(), activeOffence(presentActiveId)))))
+ .build();
+
+ // resolver points at a defendant that is not in the hearing's prosecution case
+ final OffenceOwnerResolver resolver = (resolveCaseId, offenceId) -> Optional.of(randomUUID());
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, resolver);
+
+ assertThat(offenceIds(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences()), contains(absentActiveId));
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()), contains(presentActiveId));
+ }
+
+ // ---- Cross-cutting ------------------------------------------------------
+
+ @Test
+ void shouldLeaveCourtOrderOffencesUntouched() {
+ final UUID caseId = randomUUID();
+ final UUID sharedOffenceId = randomUUID();
+ final UUID courtOrderOffenceId = randomUUID();
+
+ final CourtApplication application = CourtApplication.courtApplication()
+ .withId(randomUUID())
+ .withCourtApplicationCases(singletonList(CourtApplicationCase.courtApplicationCase()
+ .withProsecutionCaseId(caseId)
+ .withOffences(singletonList(activeOffence(sharedOffenceId)))
+ .build()))
+ .withCourtOrder(CourtOrder.courtOrder()
+ .withCourtOrderOffences(singletonList(CourtOrderOffence.courtOrderOffence()
+ .withOffence(activeOffence(courtOrderOffenceId))
+ .build()))
+ .build())
+ .build();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId, defendant(randomUUID(), activeOffence(sharedOffenceId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ final CourtOrder resultCourtOrder = result.getCourtApplications().get(0).getCourtOrder();
+ assertThat(resultCourtOrder.getCourtOrderOffences().get(0).getOffence().getId(), is(courtOrderOffenceId));
+ }
+
+ @Test
+ void shouldNotMutateInputHearing() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID sharedOffenceId = randomUUID();
+ final UUID unreferencedId = randomUUID();
+
+ final CourtApplicationCase applicationCase = CourtApplicationCase.courtApplicationCase()
+ .withProsecutionCaseId(caseId)
+ .withOffences(singletonList(activeOffence(sharedOffenceId)))
+ .build();
+ final Defendant inputDefendant = defendant(defendantId, activeOffence(sharedOffenceId), activeOffence(unreferencedId));
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(CourtApplication.courtApplication().withId(randomUUID())
+ .withCourtApplicationCases(singletonList(applicationCase)).build()))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId, inputDefendant)))
+ .build();
+
+ HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ // input application case still holds its offence; input defendant still holds both offences
+ assertThat(applicationCase.getOffences(), hasSize(1));
+ assertThat(inputDefendant.getOffences(), hasSize(2));
+ }
+
+ // ---- Multiple cases / multiple offences ---------------------------------
+
+ @Test
+ void shouldFilterOffencesIndependentlyAcrossMultipleProsecutionCases() {
+ final UUID caseId1 = randomUUID();
+ final UUID caseId2 = randomUUID();
+ final UUID defendantId1 = randomUUID();
+ final UUID defendantId2 = randomUUID();
+ final UUID activeId1 = randomUUID();
+ final UUID activeId2 = randomUUID();
+ final UUID unreferencedId1 = randomUUID();
+ final UUID unreferencedId2 = randomUUID();
+
+ // Two applications, each referencing a different case with one active offence.
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(asList(
+ application(caseId1, activeOffence(activeId1)),
+ application(caseId2, activeOffence(activeId2))))
+ .withProsecutionCases(asList(
+ prosecutionCase(caseId1, defendant(defendantId1, activeOffence(activeId1), activeOffence(unreferencedId1))),
+ prosecutionCase(caseId2, defendant(defendantId2, activeOffence(activeId2), activeOffence(unreferencedId2)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ // Each case keeps only the offence its application references.
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()), contains(activeId1));
+ assertThat(offenceIds(result.getProsecutionCases().get(1).getDefendants().get(0).getOffences()), contains(activeId2));
+ }
+
+ @Test
+ void shouldKeepBothCasesWhenEachHasAtLeastOneReferencedOffence() {
+ final UUID caseId1 = randomUUID();
+ final UUID caseId2 = randomUUID();
+ final UUID activeId1 = randomUUID();
+ final UUID activeId2 = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(asList(
+ application(caseId1, activeOffence(activeId1)),
+ application(caseId2, activeOffence(activeId2))))
+ .withProsecutionCases(asList(
+ prosecutionCase(caseId1, defendant(randomUUID(), activeOffence(activeId1))),
+ prosecutionCase(caseId2, defendant(randomUUID(), activeOffence(activeId2)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ assertThat(result.getProsecutionCases(), hasSize(2));
+ }
+
+ @Test
+ void shouldDropOnlyTheCaseWhoseDefendantsAreLeftEmptyAfterCleanup() {
+ final UUID caseId1 = randomUUID();
+ final UUID caseId2 = randomUUID();
+ final UUID activeId1 = randomUUID();
+ final UUID unreferencedId = randomUUID();
+
+ // Application references caseId1 only; caseId2's offence is unreferenced and will be dropped.
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId1, activeOffence(activeId1))))
+ .withProsecutionCases(asList(
+ prosecutionCase(caseId1, defendant(randomUUID(), activeOffence(activeId1))),
+ prosecutionCase(caseId2, defendant(randomUUID(), activeOffence(unreferencedId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ assertThat(result.getProsecutionCases(), hasSize(1));
+ assertThat(result.getProsecutionCases().get(0).getId(), is(caseId1));
+ }
+
+ @Test
+ void shouldHandleMultipleActiveOffencesAcrossMultipleDefendantsInTheSameCase() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId1 = randomUUID();
+ final UUID defendantId2 = randomUUID();
+ final UUID activeId1 = randomUUID();
+ final UUID activeId2 = randomUUID();
+ final UUID unreferencedId = randomUUID();
+
+ // Single application with two active offences; each offence belongs to a different defendant.
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, activeOffence(activeId1), activeOffence(activeId2))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId,
+ defendant(defendantId1, activeOffence(activeId1), activeOffence(unreferencedId)),
+ defendant(defendantId2, activeOffence(activeId2)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ final List resultDefendants = result.getProsecutionCases().get(0).getDefendants();
+ assertThat(resultDefendants, hasSize(2));
+ assertThat(offenceIds(resultDefendants.get(0).getOffences()), contains(activeId1));
+ assertThat(offenceIds(resultDefendants.get(1).getOffences()), contains(activeId2));
+ }
+
+ @Test
+ void shouldDropAllProsecutionCasesWhenAllApplicationOffencesConcludedAcrossMultipleCases() {
+ final UUID caseId1 = randomUUID();
+ final UUID caseId2 = randomUUID();
+
+ // Two applications, both fully concluded — prosecution cases must be dropped entirely.
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(asList(
+ application(caseId1, concludedOffence(randomUUID())),
+ application(caseId2, concludedOffence(randomUUID()))))
+ .withProsecutionCases(asList(
+ prosecutionCase(caseId1, defendant(randomUUID(), activeOffence(randomUUID()))),
+ prosecutionCase(caseId2, defendant(randomUUID(), activeOffence(randomUUID())))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ assertThat(result.getProsecutionCases(), is(nullValue()));
+ }
+
+ @Test
+ void shouldKeepOffenceInEveryProsecutionCaseWhoseIdIsInTheGlobalReferenceSet() {
+ // The reference set is global (not per-case scoped), so if an offence UUID appears in a prosecution
+ // case that was not referenced by any application it is still kept because the ID matched.
+ final UUID caseId1 = randomUUID();
+ final UUID caseId2 = randomUUID();
+ final UUID sharedOffenceId = randomUUID();
+ final UUID defendantId1 = randomUUID();
+ final UUID defendantId2 = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId1, activeOffence(sharedOffenceId))))
+ .withProsecutionCases(asList(
+ prosecutionCase(caseId1, defendant(defendantId1, activeOffence(sharedOffenceId))),
+ prosecutionCase(caseId2, defendant(defendantId2, activeOffence(sharedOffenceId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, NO_OWNER);
+
+ // Both cases survive because the shared offence ID is in the global reference set.
+ assertThat(result.getProsecutionCases(), hasSize(2));
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()), contains(sharedOffenceId));
+ assertThat(offenceIds(result.getProsecutionCases().get(1).getDefendants().get(0).getOffences()), contains(sharedOffenceId));
+ // The active offence was moved off the application.
+ assertThat(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences(), is(nullValue()));
+ }
+
+ @Test
+ void shouldApplyResolverPerCaseWhenActiveOffenceMissingFromMultipleCases() {
+ final UUID caseId1 = randomUUID();
+ final UUID caseId2 = randomUUID();
+ final UUID defendantId1 = randomUUID();
+ final UUID defendantId2 = randomUUID();
+ final UUID existingInCase1 = randomUUID();
+ final UUID existingInCase2 = randomUUID();
+ final UUID missingInCase1 = randomUUID();
+ final UUID missingInCase2 = randomUUID();
+
+ // Each application references both the existing prosecution offence and a second active offence
+ // that is absent from prosecution. The resolver must place the absent one onto the right defendant.
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(asList(
+ application(caseId1, activeOffence(existingInCase1), activeOffence(missingInCase1)),
+ application(caseId2, activeOffence(existingInCase2), activeOffence(missingInCase2))))
+ .withProsecutionCases(asList(
+ prosecutionCase(caseId1, defendant(defendantId1, activeOffence(existingInCase1))),
+ prosecutionCase(caseId2, defendant(defendantId2, activeOffence(existingInCase2)))))
+ .build();
+
+ final OffenceOwnerResolver resolver = (caseId, offenceId) -> {
+ if (missingInCase1.equals(offenceId)) return Optional.of(defendantId1);
+ if (missingInCase2.equals(offenceId)) return Optional.of(defendantId2);
+ return Optional.empty();
+ };
+
+ final Hearing result = HearingOffenceFilter.filterOffences(hearing, resolver);
+
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()),
+ containsInAnyOrder(existingInCase1, missingInCase1));
+ assertThat(offenceIds(result.getProsecutionCases().get(1).getDefendants().get(0).getOffences()),
+ containsInAnyOrder(existingInCase2, missingInCase2));
+ }
+
+ // ---- Preserving variant (merged/existing hearings) -----------------------
+ // filterOffencesPreservingHearingCaseOffences: the hearing pre-exists (confirmed/adjourn/next/extend),
+ // so its case offences are legitimately listed and must never be dropped.
+
+ @Test
+ void preservingShouldReturnSameHearingOnGuards() {
+ assertThat(HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(null, NO_OWNER), is(nullValue()));
+
+ final Hearing noApplications = Hearing.hearing()
+ .withId(randomUUID())
+ .withProsecutionCases(singletonList(prosecutionCase(randomUUID(), defendant(randomUUID(), activeOffence(randomUUID())))))
+ .build();
+ assertThat(HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(noApplications, NO_OWNER), is(sameInstance(noApplications)));
+ }
+
+ @Test
+ void preservingShouldKeepCaseOffencesWhenAllApplicationOffencesConcluded() {
+ // ste18 regression: case hearing (off2, off3 active) extended with an application whose only
+ // offence (off1) is concluded; adjourned to a next hearing - the case offences must survive.
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID concludedAppOffenceId = randomUUID();
+ final UUID caseOffenceId2 = randomUUID();
+ final UUID caseOffenceId3 = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, concludedOffence(concludedAppOffenceId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId,
+ defendant(defendantId, activeOffence(caseOffenceId2), activeOffence(caseOffenceId3)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(hearing, NO_OWNER);
+
+ // the hearing's own case offences are preserved
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()),
+ containsInAnyOrder(caseOffenceId2, caseOffenceId3));
+ // the concluded offence stays under the application
+ assertThat(offenceIds(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences()),
+ contains(concludedAppOffenceId));
+ }
+
+ @Test
+ void preservingShouldKeepCaseOffencesAndMoveActiveApplicationOffence() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID activeAppOffenceId = randomUUID();
+ final UUID caseOffenceId2 = randomUUID();
+ final UUID caseOffenceId3 = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, activeOffence(activeAppOffenceId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId,
+ defendant(defendantId, activeOffence(caseOffenceId2), activeOffence(caseOffenceId3)))))
+ .build();
+
+ final OffenceOwnerResolver resolver = (resolveCaseId, offenceId) ->
+ activeAppOffenceId.equals(offenceId) ? Optional.of(defendantId) : Optional.empty();
+
+ final Hearing result = HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(hearing, resolver);
+
+ // unrelated case offences preserved AND the active application offence moved across
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()),
+ containsInAnyOrder(caseOffenceId2, caseOffenceId3, activeAppOffenceId));
+ // active offence stripped from the application (only offence -> list nulled)
+ assertThat(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences(), is(nullValue()));
+ }
+
+ @Test
+ void preservingShouldKeepActiveApplicationOffenceAlreadyPresentUnderProsecution() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID sharedActiveId = randomUUID();
+ final UUID caseOffenceId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, activeOffence(sharedActiveId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId,
+ defendant(defendantId, activeOffence(sharedActiveId), activeOffence(caseOffenceId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(hearing, NO_OWNER);
+
+ // shared offence kept once under prosecution alongside the unrelated case offence
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()),
+ containsInAnyOrder(sharedActiveId, caseOffenceId));
+ // and stripped from the application side
+ assertThat(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences(), is(nullValue()));
+ }
+
+ @Test
+ void preservingShouldDedupConcludedApplicationOffenceOffTheProsecutionSide() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID concludedAppOffenceId = randomUUID();
+ final UUID caseOffenceId = randomUUID();
+
+ // the concluded application offence also (wrongly) sits under prosecution -> deduped off it
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, concludedOffence(concludedAppOffenceId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId,
+ defendant(defendantId, concludedOffence(concludedAppOffenceId), activeOffence(caseOffenceId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(hearing, NO_OWNER);
+
+ assertThat(offenceIds(result.getProsecutionCases().get(0).getDefendants().get(0).getOffences()), contains(caseOffenceId));
+ assertThat(offenceIds(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences()),
+ contains(concludedAppOffenceId));
+ }
+
+ @Test
+ void preservingShouldNullProsecutionCasesWhenOnlyApplicationDuplicatesRemain() {
+ final UUID caseId = randomUUID();
+ final UUID concludedAppOffenceId = randomUUID();
+
+ // pure application hearing: prosecution side only mirrors the concluded application offence
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, concludedOffence(concludedAppOffenceId))))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId,
+ defendant(randomUUID(), concludedOffence(concludedAppOffenceId)))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(hearing, NO_OWNER);
+
+ // schema-safe: null, never an empty array
+ assertThat(result.getProsecutionCases(), is(nullValue()));
+ assertThat(offenceIds(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences()),
+ contains(concludedAppOffenceId));
+ }
+
+ @Test
+ void preservingShouldLeaveNullProsecutionCasesNullForPureApplicationHearing() {
+ final UUID caseId = randomUUID();
+ final UUID concludedAppOffenceId = randomUUID();
+
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(application(caseId, concludedOffence(concludedAppOffenceId))))
+ .build();
+
+ final Hearing result = HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(hearing, NO_OWNER);
+
+ assertThat(result.getProsecutionCases(), is(nullValue()));
+ assertThat(offenceIds(result.getCourtApplications().get(0).getCourtApplicationCases().get(0).getOffences()),
+ contains(concludedAppOffenceId));
+ }
+
+ @Test
+ void preservingShouldNotMutateInputHearing() {
+ final UUID caseId = randomUUID();
+ final UUID defendantId = randomUUID();
+ final UUID activeAppOffenceId = randomUUID();
+ final UUID caseOffenceId = randomUUID();
+
+ final CourtApplicationCase applicationCase = CourtApplicationCase.courtApplicationCase()
+ .withProsecutionCaseId(caseId)
+ .withOffences(singletonList(activeOffence(activeAppOffenceId)))
+ .build();
+ final Defendant inputDefendant = defendant(defendantId, activeOffence(caseOffenceId));
+ final Hearing hearing = Hearing.hearing()
+ .withId(randomUUID())
+ .withCourtApplications(singletonList(CourtApplication.courtApplication().withId(randomUUID())
+ .withCourtApplicationCases(singletonList(applicationCase)).build()))
+ .withProsecutionCases(singletonList(prosecutionCase(caseId, inputDefendant)))
+ .build();
+
+ final OffenceOwnerResolver resolver = (resolveCaseId, offenceId) -> Optional.of(defendantId);
+
+ HearingOffenceFilter.filterOffencesPreservingHearingCaseOffences(hearing, resolver);
+
+ assertThat(applicationCase.getOffences(), hasSize(1));
+ assertThat(inputDefendant.getOffences(), hasSize(1));
+ }
+
+ // ---- Fixture helpers ----------------------------------------------------
+
+ private static Offence activeOffence(final UUID id) {
+ return Offence.offence().withId(id).withProceedingsConcluded(false).build();
+ }
+
+ private static Offence concludedOffence(final UUID id) {
+ return Offence.offence().withId(id).withProceedingsConcluded(true).build();
+ }
+
+ private static CourtApplication application(final UUID prosecutionCaseId, final Offence... offences) {
+ return CourtApplication.courtApplication()
+ .withId(randomUUID())
+ .withCourtApplicationCases(singletonList(CourtApplicationCase.courtApplicationCase()
+ .withProsecutionCaseId(prosecutionCaseId)
+ .withOffences(asList(offences))
+ .build()))
+ .build();
+ }
+
+ private static Defendant defendant(final UUID id, final Offence... offences) {
+ return Defendant.defendant().withId(id).withOffences(asList(offences)).build();
+ }
+
+ private static ProsecutionCase prosecutionCase(final UUID id, final Defendant... defendants) {
+ return ProsecutionCase.prosecutionCase().withId(id).withDefendants(asList(defendants)).build();
+ }
+
+ private static List offenceIds(final List offences) {
+ return offences.stream().map(Offence::getId).collect(Collectors.toList());
+ }
+}
diff --git a/progression-event/progression-event-processor/src/test/resources/expected.progression.event.application-referred-to-court-hearing.json b/progression-event/progression-event-processor/src/test/resources/expected.progression.event.application-referred-to-court-hearing.json
index f5b15c238..8715f784c 100644
--- a/progression-event/progression-event-processor/src/test/resources/expected.progression.event.application-referred-to-court-hearing.json
+++ b/progression-event/progression-event-processor/src/test/resources/expected.progression.event.application-referred-to-court-hearing.json
@@ -75,7 +75,8 @@
},
"startDate": "2020-03-10",
"wording": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
- "wordingWelsh": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 "
+ "wordingWelsh": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
+ "proceedingsConcluded": false
}
],
"caseStatus": "ACTIVE"
diff --git a/progression-event/progression-event-processor/src/test/resources/progression.event.application-referred-to-court-hearing.json b/progression-event/progression-event-processor/src/test/resources/progression.event.application-referred-to-court-hearing.json
index b3fd4922d..db5f16b77 100644
--- a/progression-event/progression-event-processor/src/test/resources/progression.event.application-referred-to-court-hearing.json
+++ b/progression-event/progression-event-processor/src/test/resources/progression.event.application-referred-to-court-hearing.json
@@ -72,7 +72,8 @@
},
"startDate": "2020-03-10",
"wording": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
- "wordingWelsh": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 "
+ "wordingWelsh": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
+ "proceedingsConcluded": false
}
],
"caseStatus": "ACTIVE"
diff --git a/progression-integration-test/src/test/java/uk/gov/moj/cpp/progression/CreateCourtApplicationIT.java b/progression-integration-test/src/test/java/uk/gov/moj/cpp/progression/CreateCourtApplicationIT.java
index 40c6d7f3f..43baaa545 100644
--- a/progression-integration-test/src/test/java/uk/gov/moj/cpp/progression/CreateCourtApplicationIT.java
+++ b/progression-integration-test/src/test/java/uk/gov/moj/cpp/progression/CreateCourtApplicationIT.java
@@ -1,5 +1,6 @@
package uk.gov.moj.cpp.progression;
+import static com.jayway.jsonpath.matchers.JsonPathMatchers.hasNoJsonPath;
import static com.jayway.jsonpath.matchers.JsonPathMatchers.withJsonPath;
import static java.util.UUID.randomUUID;
import static org.hamcrest.CoreMatchers.equalTo;
@@ -32,6 +33,10 @@
@SuppressWarnings("squid:S1607")
public class CreateCourtApplicationIT extends AbstractIT {
private static final String COURT_APPLICATION_CREATED = "public.progression.court-application-created";
+ private static final String MH_ACTIVE_CASE_FIXTURE =
+ "applications/progression.initiate-court-proceedings-mh-source-active-case.json";
+ private static final String MH_INACTIVE_CASE_FIXTURE =
+ "applications/progression.initiate-court-proceedings-mh-source-inactive-case.json";
private final JmsMessageConsumerClient consumerForCourtApplicationCreated = newPublicJmsMessageConsumerClientProvider().withEventNames(COURT_APPLICATION_CREATED).getMessageConsumerClient();
@@ -109,6 +114,55 @@ public void shouldCreateCourtApplicationLinkedWithCaseAndGetConfirmation() throw
pollProsecutionCasesProgressionFor(caseId, caseMatchers);
}
+ @Test
+ public void shouldNotStoreOffencesWhenApplicationSourceIsMHAndCaseIsActive() throws Exception {
+ addProsecutionCaseToCrownCourt(caseId, defendantId);
+ pollProsecutionCasesProgressionFor(caseId, getProsecutionCaseMatchers(caseId, defendantId));
+
+ final String applicationId = randomUUID().toString();
+
+ initiateCourtProceedingsForCourtApplication(applicationId, caseId, MH_ACTIVE_CASE_FIXTURE);
+
+ verifyCourtApplicationCreatedEventPublished(applicationId);
+
+ final Matcher[] matchers = {
+ withJsonPath("$.courtApplication.id", is(applicationId)),
+ withJsonPath("$.courtApplication.applicationStatus", notNullValue()),
+ hasNoJsonPath("$.courtApplication.courtApplicationCases[0].offences")
+ };
+
+ pollForApplication(applicationId, matchers);
+ }
+
+ @Test
+ public void shouldPreserveOffencesWhenApplicationSourceIsMHAndCaseIsInactive() throws Exception {
+ final String defendantId = randomUUID().toString();
+ addProsecutionCaseToCrownCourt(caseId, defendantId);
+ pollProsecutionCasesProgressionFor(caseId, getProsecutionCaseMatchers(caseId, defendantId));
+
+ final String applicationId = randomUUID().toString();
+
+ initiateCourtProceedingsForCourtApplication(applicationId, caseId, MH_INACTIVE_CASE_FIXTURE);
+
+ verifyCourtApplicationCreatedEventPublished(applicationId);
+
+ final Matcher[] matchers = {
+ withJsonPath("$.courtApplication.id", is(applicationId)),
+ withJsonPath("$.courtApplication.courtApplicationCases[0].caseStatus", is("INACTIVE")),
+ withJsonPath("$.courtApplication.courtApplicationCases[0].offences[0]", notNullValue()),
+ withJsonPath("$.courtApplication.courtApplicationCases[0].offences[0].offenceCode", is("CA03012"))
+ };
+
+ pollForApplication(applicationId, matchers);
+ }
+
+ private void verifyCourtApplicationCreatedEventPublished(final String applicationId) {
+ final Optional message = retrieveMessageBody(consumerForCourtApplicationCreated);
+ assertTrue(message.isPresent(), "Expected court-application-created event on JMS topic");
+ final String idFromEvent = message.get().getJsonObject("courtApplication").getString("id");
+ assertThat(idFromEvent, equalTo(applicationId));
+ }
+
private void verifyInMessagingQueueForCourtApplicationCreated(String applicationId) {
final Optional message = retrieveMessageBody(consumerForCourtApplicationCreated);
assertTrue(message.isPresent());
diff --git a/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-application-reporder.json b/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-application-reporder.json
index d1028425c..579aa3edb 100644
--- a/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-application-reporder.json
+++ b/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-application-reporder.json
@@ -221,7 +221,8 @@
},
"startDate": "2020-03-10",
"wording": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
- "wordingWelsh": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 "
+ "wordingWelsh": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
+ "proceedingsConcluded": true
}
]
}
diff --git a/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-application-update3.json b/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-application-update3.json
index 0f11ca0a6..d12af3617 100644
--- a/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-application-update3.json
+++ b/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-application-update3.json
@@ -191,7 +191,8 @@
},
"startDate": "2020-03-10",
"wording": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
- "wordingWelsh": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 "
+ "wordingWelsh": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
+ "proceedingsConcluded": true
}
]
}
diff --git a/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-court-appeal-application.json b/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-court-appeal-application.json
index 672401bf9..c14cc3d6e 100644
--- a/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-court-appeal-application.json
+++ b/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-for-court-appeal-application.json
@@ -139,7 +139,8 @@
},
"startDate": "2020-03-10",
"wording": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
- "wordingWelsh": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 "
+ "wordingWelsh": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
+ "proceedingsConcluded": true
}
]
}
diff --git a/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-mh-source-active-case.json b/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-mh-source-active-case.json
new file mode 100644
index 000000000..f609f2c0e
--- /dev/null
+++ b/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-mh-source-active-case.json
@@ -0,0 +1,100 @@
+{
+ "courtApplication": {
+ "id": "APPLICATION_ID",
+ "type": {
+ "id": "e857c8ea-cd95-47d1-842f-2d618e77a9b5",
+ "code": "AS14518",
+ "type": "Application for an order of reimbursement in relation to a closure order",
+ "legislation": "In accordance with section 16E of the Magistrates' Courts Act 1980.",
+ "categoryCode": "VP",
+ "linkType": "LINKED",
+ "jurisdiction": "MAGISTRATES",
+ "summonsTemplateType": "GENERIC_APPLICATION",
+ "breachType": "NOT_APPLICABLE",
+ "appealFlag": false,
+ "applicantAppellantFlag": false,
+ "pleaApplicableFlag": false,
+ "commrOfOathFlag": false,
+ "courtOfAppealFlag": false,
+ "courtExtractAvlFlag": false,
+ "prosecutorThirdPartyFlag": false,
+ "spiOutApplicableFlag": false,
+ "offenceActiveOrder": "NOT_APPLICABLE"
+ },
+ "applicationReceivedDate": "2020-01-01",
+ "applicationReference": "AS145197659",
+ "applicant": {
+ "id": "9ce6e439-d5da-4202-a446-ef4ca7072540",
+ "summonsRequired": false,
+ "notificationRequired": true
+ },
+ "subject": {
+ "id": "cd3b251d-20e8-44ad-b95e-2f81afde56a4",
+ "summonsRequired": false,
+ "notificationRequired": true
+ },
+ "applicationStatus": "DRAFT",
+ "outOfTimeReasons": "MH source active case — offences must not be stored",
+ "courtApplicationCases": [
+ {
+ "prosecutionCaseId": "CASE_ID",
+ "prosecutionCaseIdentifier": {
+ "prosecutionAuthorityId": "cf73207f-3ced-488a-82a0-3fba79c2ce85",
+ "prosecutionAuthorityCode": "TFL",
+ "caseURN": "TFL4359536"
+ },
+ "isSJP": false,
+ "caseStatus": "ACTIVE",
+ "offences": [
+ {
+ "id": "3ebe41c9-666d-4964-aa80-a005d89927a4",
+ "chargeDate": "2020-03-14",
+ "count": 1,
+ "isDisposed": false,
+ "offenceCode": "CA03012",
+ "offenceDefinitionId": "3ebe41c9-666d-4964-aa80-a005d89927a3",
+ "offenceLegislation": "Contrary to section 363(3)(b) and (4) of the Communications Act 2003.",
+ "offenceLegislationWelsh": "",
+ "offenceTitle": "Active offence that should be suppressed when source is MH",
+ "offenceTitleWelsh": "",
+ "orderIndex": 1,
+ "startDate": "2020-03-10",
+ "wording": "MH source active offence wording",
+ "wordingWelsh": "MH source active offence wording welsh"
+ }
+ ]
+ }
+ ]
+ },
+ "courtHearing": {
+ "hearingType": {
+ "id": "8cdfd3da-8900-42ca-9835-9f29d1e03cd6",
+ "description": "Sentence"
+ },
+ "jurisdictionType": "MAGISTRATES",
+ "listedStartDateTime": "2020-12-21T05:27:17.210Z",
+ "estimatedMinutes": 20,
+ "earliestStartDateTime": "2020-12-21T05:27:17.210Z",
+ "courtCentre": {
+ "address": {
+ "address1": "176A Lavender Hill",
+ "address2": "London",
+ "address3": "",
+ "address4": "",
+ "address5": "",
+ "postcode": "SW11 1JU"
+ },
+ "code": "B01LY00",
+ "id": "f8254db1-1683-483e-afb3-b87fde5a0a26",
+ "lja": {
+ "ljaCode": "2577",
+ "ljaName": "South West London Magistrates' Court"
+ },
+ "name": "Lavender Hill Magistrates' Court",
+ "roomId": "9e4932f7-97b2-3010-b942-ddd2624e4dd8",
+ "roomName": "Courtroom 01"
+ }
+ },
+ "applicationSource": "MH",
+ "summonsApprovalRequired": false
+}
diff --git a/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-mh-source-inactive-case.json b/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-mh-source-inactive-case.json
new file mode 100644
index 000000000..abcf41404
--- /dev/null
+++ b/progression-integration-test/src/test/resources/applications/progression.initiate-court-proceedings-mh-source-inactive-case.json
@@ -0,0 +1,100 @@
+{
+ "courtApplication": {
+ "id": "APPLICATION_ID",
+ "type": {
+ "id": "e857c8ea-cd95-47d1-842f-2d618e77a9b5",
+ "code": "AS14518",
+ "type": "Application for an order of reimbursement in relation to a closure order",
+ "legislation": "In accordance with section 16E of the Magistrates' Courts Act 1980.",
+ "categoryCode": "VP",
+ "linkType": "LINKED",
+ "jurisdiction": "MAGISTRATES",
+ "summonsTemplateType": "GENERIC_APPLICATION",
+ "breachType": "GENERIC_BREACH",
+ "appealFlag": false,
+ "applicantAppellantFlag": false,
+ "pleaApplicableFlag": false,
+ "commrOfOathFlag": false,
+ "courtOfAppealFlag": false,
+ "courtExtractAvlFlag": false,
+ "prosecutorThirdPartyFlag": false,
+ "spiOutApplicableFlag": false,
+ "offenceActiveOrder": "NOT_APPLICABLE"
+ },
+ "applicationReceivedDate": "2020-01-01",
+ "applicationReference": "AS145197659",
+ "applicant": {
+ "id": "9ce6e439-d5da-4202-a446-ef4ca7072540",
+ "summonsRequired": false,
+ "notificationRequired": true
+ },
+ "subject": {
+ "id": "cd3b251d-20e8-44ad-b95e-2f81afde56a4",
+ "summonsRequired": false,
+ "notificationRequired": true
+ },
+ "applicationStatus": "DRAFT",
+ "outOfTimeReasons": "MH source inactive breach case — offences must be preserved",
+ "courtApplicationCases": [
+ {
+ "prosecutionCaseId": "CASE_ID",
+ "prosecutionCaseIdentifier": {
+ "prosecutionAuthorityId": "cf73207f-3ced-488a-82a0-3fba79c2ce85",
+ "prosecutionAuthorityCode": "TFL",
+ "caseURN": "TFL4359536"
+ },
+ "isSJP": false,
+ "caseStatus": "INACTIVE",
+ "offences": [
+ {
+ "id": "9ce6e439-d5da-4202-a446-ef4ca7072530",
+ "chargeDate": "2020-03-14",
+ "count": 1,
+ "isDisposed": true,
+ "offenceCode": "CA03012",
+ "offenceDefinitionId": "3ebe41c9-666d-4964-aa80-a005d89927a3",
+ "offenceLegislation": "Contrary to section 363(3)(b) and (4) of the Communications Act 2003.",
+ "offenceLegislationWelsh": "",
+ "offenceTitle": "Inactive offence for breach hearing that should be preserved",
+ "offenceTitleWelsh": "",
+ "orderIndex": 1,
+ "startDate": "2020-03-10",
+ "wording": "MH source inactive offence wording",
+ "wordingWelsh": "MH source inactive offence wording welsh"
+ }
+ ]
+ }
+ ]
+ },
+ "courtHearing": {
+ "hearingType": {
+ "id": "8cdfd3da-8900-42ca-9835-9f29d1e03cd6",
+ "description": "Breach Hearing"
+ },
+ "jurisdictionType": "MAGISTRATES",
+ "listedStartDateTime": "2020-12-21T05:27:17.210Z",
+ "estimatedMinutes": 20,
+ "earliestStartDateTime": "2020-12-21T05:27:17.210Z",
+ "courtCentre": {
+ "address": {
+ "address1": "176A Lavender Hill",
+ "address2": "London",
+ "address3": "",
+ "address4": "",
+ "address5": "",
+ "postcode": "SW11 1JU"
+ },
+ "code": "B01LY00",
+ "id": "f8254db1-1683-483e-afb3-b87fde5a0a26",
+ "lja": {
+ "ljaCode": "2577",
+ "ljaName": "South West London Magistrates' Court"
+ },
+ "name": "Lavender Hill Magistrates' Court",
+ "roomId": "9e4932f7-97b2-3010-b942-ddd2624e4dd8",
+ "roomName": "Courtroom 01"
+ }
+ },
+ "applicationSource": "MH",
+ "summonsApprovalRequired": false
+}
diff --git a/progression-integration-test/src/test/resources/expected/expected.progression.application-laa-query-response-payload.json b/progression-integration-test/src/test/resources/expected/expected.progression.application-laa-query-response-payload.json
index 176b18563..e8c54ffff 100644
--- a/progression-integration-test/src/test/resources/expected/expected.progression.application-laa-query-response-payload.json
+++ b/progression-integration-test/src/test/resources/expected/expected.progression.application-laa-query-response-payload.json
@@ -56,7 +56,8 @@
"offenceTitle": "Possess / control TV set with intent another use install without a licence",
"orderIndex": 1,
"startDate": "2020-03-10",
- "wording": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 "
+ "wording": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
+ "proceedingsConcluded": true
}
],
"subjectId": "cd3b251d-20e8-44ad-b95e-2f81afde56a4"
diff --git a/progression-integration-test/src/test/resources/expected/expected.progression.application-referred-to-court-hearing.json b/progression-integration-test/src/test/resources/expected/expected.progression.application-referred-to-court-hearing.json
index 8eccd7626..a0401c3f4 100644
--- a/progression-integration-test/src/test/resources/expected/expected.progression.application-referred-to-court-hearing.json
+++ b/progression-integration-test/src/test/resources/expected/expected.progression.application-referred-to-court-hearing.json
@@ -77,7 +77,8 @@
"wording": "On 01/11/2017 at Chelmsford intentionally obstructed a person authorised by the BBC in the exercise of a power conferred by virtue of a search warrant issued under section 366 of the Communications Act 2003 by Chelmsford Magistrates Court on 25/10/2017 ",
"chargeDate": "2020-03-14",
"offenceDefinitionId": "3ebe41c9-666d-4964-aa80-a005d89927a3",
- "startDate": "2020-03-10"
+ "startDate": "2020-03-10",
+ "proceedingsConcluded": true
}
],
"isSJP": false,
diff --git a/progression-viewstore/progression-viewstore-liquibase/src/main/resources/liquibase/refactor-court-application-constraints-and-mdch-index.xml b/progression-viewstore/progression-viewstore-liquibase/src/main/resources/liquibase/refactor-court-application-constraints-and-mdch-index.xml
new file mode 100644
index 000000000..29dc42858
--- /dev/null
+++ b/progression-viewstore/progression-viewstore-liquibase/src/main/resources/liquibase/refactor-court-application-constraints-and-mdch-index.xml
@@ -0,0 +1,43 @@
+
+
+
+
+
+
+ ALTER TABLE court_application_case
+ DROP CONSTRAINT IF EXISTS court_application_case_unique_key;
+
+
+
+
+
+
+ DO $$
+ BEGIN
+ IF NOT EXISTS (
+ SELECT 1
+ FROM information_schema.table_constraints tc
+ WHERE tc.constraint_name = 'court_application_case_unique_key'
+ AND tc.table_name = 'court_application_case'
+ AND tc.constraint_type = 'UNIQUE'
+ ) THEN
+ ALTER TABLE court_application_case
+ ADD CONSTRAINT court_application_case_unique_key UNIQUE (case_id, application_id);
+ END IF;
+ END
+ $$;
+
+
+
+
+
+
+ CREATE INDEX IF NOT EXISTS match_defendant_case_hearing_prosecution_case_id_idx
+ ON match_defendant_case_hearing (prosecution_case_id);
+
+
+
+
\ No newline at end of file
diff --git a/progression-viewstore/progression-viewstore-liquibase/src/main/resources/liquibase/view-store-db-changelog.xml b/progression-viewstore/progression-viewstore-liquibase/src/main/resources/liquibase/view-store-db-changelog.xml
index 540d022aa..5f4728a4d 100644
--- a/progression-viewstore/progression-viewstore-liquibase/src/main/resources/liquibase/view-store-db-changelog.xml
+++ b/progression-viewstore/progression-viewstore-liquibase/src/main/resources/liquibase/view-store-db-changelog.xml
@@ -119,4 +119,5 @@
+
\ No newline at end of file