Isolated dto API showcase

build.gradle

@@ -95,6 +95,11 @@ ccd {
   configDir = file('build/definitions')
   decentralised = true
   runtimeIndexing = !integrationBuild
+  tsBindings {
+    enabled = true
+    outputDir.set(layout.projectDirectory.dir('../pcs-frontend/src/main/generated/ccd'))
+    moduleName = 'pcs'
+  }
 }
 
 tasks.withType(JavaCompile).configureEach {

src/cftlibTest/java/uk/gov/hmcts/reform/pcs/CreatePossessionClaimTest.java

@@ -11,6 +11,7 @@
 import org.junit.jupiter.api.TestMethodOrder;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
+import uk.gov.hmcts.ccd.sdk.CcdEventTestClient;
 import uk.gov.hmcts.ccd.sdk.type.AddressUK;
 import uk.gov.hmcts.ccd.sdk.type.ListValue;
 import uk.gov.hmcts.ccd.sdk.type.YesOrNo;
@@ -30,14 +31,15 @@
 import uk.gov.hmcts.reform.pcs.ccd.domain.TenancyLicenceDetails;
 import uk.gov.hmcts.reform.pcs.ccd.domain.TenancyLicenceType;
 import uk.gov.hmcts.reform.pcs.ccd.domain.VerticalYesNo;
+import uk.gov.hmcts.reform.pcs.ccd.dto.CreateClaimData;
 import uk.gov.hmcts.reform.pcs.ccd.event.EventId;
 import uk.gov.hmcts.reform.pcs.postcodecourt.model.LegislativeCountry;
 import uk.gov.hmcts.rse.ccd.lib.test.CftlibTest;
 
 import java.util.List;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static uk.gov.hmcts.reform.pcs.ccd.event.EventId.createPossessionClaim;
+import static uk.gov.hmcts.reform.pcs.ccd.event.CreatePossessionClaim.EVENT;
 import static uk.gov.hmcts.reform.pcs.ccd.event.EventId.resumePossessionClaim;
 
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@@ -54,6 +56,9 @@ class CreatePossessionClaimTest extends CftlibTest {
     @Autowired
     private ObjectMapper objectMapper;
 
+    @Autowired
+    private CcdEventTestClient ccdEventTestClient;
+
     private String idamToken;
     private String s2sToken;
     private Long caseReference;
@@ -67,20 +72,24 @@ void setup() {
     @Test
     @Order(1)
     void createPossessionClaim() {
-
-        PCSCase caseData = PCSCase.builder()
+        CreateClaimData caseData = CreateClaimData.builder()
             .propertyAddress(AddressUK.builder()
                                  .addressLine1("123 Baker Street")
                                  .addressLine2("Marylebone")
                                  .postTown("London")
                                  .county("Greater London")
                                  .postCode("NW1 6XE")
-                                 .build()
-            )
+                                 .build())
             .legislativeCountry(LegislativeCountry.ENGLAND)
             .build();
 
-        CaseDetails caseDetails = startAndSubmitCreationEvent(createPossessionClaim, caseData);
+        CaseDetails caseDetails = ccdEventTestClient.startAndSubmitCreateEvent(
+            idamToken,
+            s2sToken,
+            CaseType.getCaseType(),
+            EVENT,
+            caseData
+        );
 
         caseReference = caseDetails.getId();
         assertThat(caseReference).isNotNull();
@@ -126,24 +135,6 @@ void resumePossessionClaim() {
         assertThat(retrievedCase.getState()).isEqualTo(State.PENDING_CASE_ISSUED.name());
     }
 
-    @SuppressWarnings("SameParameterValue")
-    private CaseDetails startAndSubmitCreationEvent(EventId eventId, PCSCase caseData) {
-        StartEventResponse startEventResponse = ccdApi.startCase(
-            idamToken,
-            s2sToken,
-            CaseType.getCaseType(),
-            eventId.name()
-        );
-
-        CaseDataContent content = CaseDataContent.builder()
-            .data(caseData)
-            .event(Event.builder().id(eventId.name()).build())
-            .eventToken(startEventResponse.getToken())
-            .build();
-
-        return ccdApi.submitCaseCreation(idamToken, s2sToken, CaseType.getCaseType(), content);
-    }
-
     @SuppressWarnings("SameParameterValue")
     private CaseResource startAndSubmitUpdateEvent(EventId eventId, PCSCase caseData) {
         StartEventResponse startEventResponse = ccdApi.startEvent(

src/main/java/uk/gov/hmcts/reform/pcs/ccd/dto/CreateClaimData.java

@@ -0,0 +1,31 @@
+package uk.gov.hmcts.reform.pcs.ccd.dto;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import uk.gov.hmcts.ccd.sdk.api.CCD;
+import uk.gov.hmcts.ccd.sdk.type.AddressUK;
+import uk.gov.hmcts.ccd.sdk.type.FieldType;
+import uk.gov.hmcts.ccd.sdk.type.YesOrNo;
+import uk.gov.hmcts.reform.pcs.ccd.type.DynamicStringList;
+import uk.gov.hmcts.reform.pcs.postcodecourt.model.LegislativeCountry;
+
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class CreateClaimData {
+    @CCD(ignore = true)
+    private AddressUK propertyAddress;
+    private LegislativeCountry legislativeCountry;
+    private String feeAmount;
+    private YesOrNo showCrossBorderPage;
+    private YesOrNo showPropertyNotEligiblePage;
+    private YesOrNo showPostcodeNotAssignedToCourt;
+    @CCD(typeOverride = FieldType.DynamicRadioList)
+    private DynamicStringList crossBorderCountriesList;
+    private String crossBorderCountry1;
+    private String crossBorderCountry2;
+    private String postcodeNotAssignedView;
+}

src/main/java/uk/gov/hmcts/reform/pcs/ccd/event/CreatePossessionClaim.java

@@ -4,15 +4,16 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import uk.gov.hmcts.ccd.sdk.api.CCDConfig;
+import uk.gov.hmcts.ccd.sdk.api.CcdEventBinding;
 import uk.gov.hmcts.ccd.sdk.api.DecentralisedConfigBuilder;
 import uk.gov.hmcts.ccd.sdk.api.Event.EventBuilder;
 import uk.gov.hmcts.ccd.sdk.api.EventPayload;
 import uk.gov.hmcts.ccd.sdk.api.Permission;
 import uk.gov.hmcts.ccd.sdk.api.callback.SubmitResponse;
 import uk.gov.hmcts.reform.pcs.ccd.accesscontrol.UserRole;
-import uk.gov.hmcts.reform.pcs.ccd.common.PageBuilder;
 import uk.gov.hmcts.reform.pcs.ccd.domain.PCSCase;
 import uk.gov.hmcts.reform.pcs.ccd.domain.State;
+import uk.gov.hmcts.reform.pcs.ccd.dto.CreateClaimData;
 import uk.gov.hmcts.reform.pcs.ccd.page.createpossessionclaim.CrossBorderPostcodeSelection;
 import uk.gov.hmcts.reform.pcs.ccd.page.createpossessionclaim.EnterPropertyAddress;
 import uk.gov.hmcts.reform.pcs.ccd.page.createpossessionclaim.PostcodeNotAssignedToCourt;
@@ -22,6 +23,8 @@
 import uk.gov.hmcts.reform.pcs.ccd.util.FeeApplier;
 import uk.gov.hmcts.reform.pcs.feesandpay.model.FeeType;
 
+import java.util.function.Consumer;
+
 import static uk.gov.hmcts.reform.pcs.ccd.event.EventId.createPossessionClaim;
 
 
@@ -30,6 +33,9 @@
 @AllArgsConstructor
 public class CreatePossessionClaim implements CCDConfig<PCSCase, State, UserRole> {
 
+    public static final CcdEventBinding<CreateClaimData> EVENT =
+        CcdEventBinding.of(createPossessionClaim.name(), "cpc", CreateClaimData.class);
+
     private final PcsCaseService pcsCaseService;
     private final FeeApplier feeApplier;
     private final EnterPropertyAddress enterPropertyAddress;
@@ -38,41 +44,35 @@ public class CreatePossessionClaim implements CCDConfig<PCSCase, State, UserRole
 
     @Override
     public void configureDecentralised(DecentralisedConfigBuilder<PCSCase, State, UserRole> configBuilder) {
-        EventBuilder<PCSCase, UserRole, State> eventBuilder =
+        EventBuilder<CreateClaimData, UserRole, State> eventBuilder =
             configBuilder
-                .decentralisedEvent(createPossessionClaim.name(), this::submit, this::start)
+                .decentralisedEvent(EVENT, this::submit, this::start)
                 .initialState(State.AWAITING_SUBMISSION_TO_HMCTS)
                 .showSummary()
                 .name("Make a claim")
                 .grant(Permission.CRUD, UserRole.PCS_SOLICITOR);
 
-        new PageBuilder(eventBuilder)
-            .add(new StartTheService())
-            .add(enterPropertyAddress)
-            .add(crossBorderPostcodeSelection)
-            .add(propertyNotEligible)
-            .add(new PostcodeNotAssignedToCourt());
-
+        new StartTheService().addTo(eventBuilder);
+        enterPropertyAddress.addTo(eventBuilder);
+        crossBorderPostcodeSelection.addTo(eventBuilder);
+        propertyNotEligible.addTo(eventBuilder);
+        new PostcodeNotAssignedToCourt().addTo(eventBuilder);
     }
 
-    private PCSCase start(EventPayload<PCSCase, State> eventPayload) {
-        PCSCase caseData = eventPayload.caseData();
+    private CreateClaimData start(EventPayload<CreateClaimData, State> eventPayload) {
+        CreateClaimData caseData = eventPayload.caseData();
 
-        applyCaseIssueFeeAmount(caseData);
+        applyCaseIssueFeeAmount(caseData::setFeeAmount);
         return caseData;
     }
 
-    private void applyCaseIssueFeeAmount(PCSCase pcsCase) {
-        feeApplier.applyFeeAmount(
-            pcsCase,
-            FeeType.CASE_ISSUE_FEE,
-            PCSCase::setFeeAmount
-        );
+    private void applyCaseIssueFeeAmount(Consumer<String> setter) {
+        feeApplier.applyFeeAmount(FeeType.CASE_ISSUE_FEE, setter);
     }
 
-    private SubmitResponse<State> submit(EventPayload<PCSCase, State> eventPayload) {
+    private SubmitResponse<State> submit(EventPayload<CreateClaimData, State> eventPayload) {
         long caseReference = eventPayload.caseReference();
-        PCSCase caseData = eventPayload.caseData();
+        CreateClaimData caseData = eventPayload.caseData();
 
         pcsCaseService.createCase(caseReference, caseData.getPropertyAddress(), caseData.getLegislativeCountry());
 

src/main/java/uk/gov/hmcts/reform/pcs/ccd/event/enforcetheorder/EnforceTheOrder.java

@@ -91,15 +91,16 @@ private void populateDefendantSelectionList(PCSCase caseData) {
     }
 
     private void applyWarrantFeeAmount(PCSCase pcsCase) {
-        feeApplier.applyFeeAmount(pcsCase,
+        feeApplier.applyFeeAmount(
             FeeType.ENFORCEMENT_WARRANT_FEE,
-            (caseData, fee) -> caseData.getEnforcementOrder().setWarrantFeeAmount(fee));
+            pcsCase.getEnforcementOrder()::setWarrantFeeAmount
+        );
     }
 
     private void applyWritFeeAmount(PCSCase pcsCase) {
-        feeApplier.applyFeeAmount(pcsCase,
+        feeApplier.applyFeeAmount(
             FeeType.ENFORCEMENT_WRIT_FEE,
-            (caseData, fee) -> caseData.getEnforcementOrder().setWritFeeAmount(fee)
+            pcsCase.getEnforcementOrder()::setWritFeeAmount
         );
     }
 

src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/createpossessionclaim/CrossBorderPostcodeSelection.java

@@ -6,11 +6,11 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
 import uk.gov.hmcts.ccd.sdk.api.CaseDetails;
+import uk.gov.hmcts.ccd.sdk.api.Event.EventBuilder;
 import uk.gov.hmcts.ccd.sdk.api.callback.AboutToStartOrSubmitResponse;
 import uk.gov.hmcts.ccd.sdk.type.YesOrNo;
-import uk.gov.hmcts.reform.pcs.ccd.common.CcdPageConfiguration;
-import uk.gov.hmcts.reform.pcs.ccd.common.PageBuilder;
-import uk.gov.hmcts.reform.pcs.ccd.domain.PCSCase;
+import uk.gov.hmcts.reform.pcs.ccd.accesscontrol.UserRole;
+import uk.gov.hmcts.reform.pcs.ccd.dto.CreateClaimData;
 import uk.gov.hmcts.reform.pcs.ccd.domain.State;
 import uk.gov.hmcts.reform.pcs.postcodecourt.exception.EligibilityCheckException;
 import uk.gov.hmcts.reform.pcs.postcodecourt.model.EligibilityResult;
@@ -24,19 +24,18 @@
 @AllArgsConstructor
 @Component
 @Slf4j
-public class CrossBorderPostcodeSelection implements CcdPageConfiguration {
+public class CrossBorderPostcodeSelection {
 
     private final EligibilityService eligibilityService;
 
-    @Override
-    public void addTo(PageBuilder pageBuilder) {
-        pageBuilder
+    public void addTo(EventBuilder<CreateClaimData, UserRole, State> eventBuilder) {
+        eventBuilder.fields()
             .page("crossBorderPostcodeSelection", this::midEvent)
             .pageLabel("Border postcode")
             .showCondition("showCrossBorderPage=\"Yes\"")
-            .readonly(PCSCase::getShowCrossBorderPage, NEVER_SHOW)
-            .readonly(PCSCase::getCrossBorderCountry1, NEVER_SHOW, true)
-            .readonly(PCSCase::getCrossBorderCountry2, NEVER_SHOW, true)
+            .readonly(CreateClaimData::getShowCrossBorderPage, NEVER_SHOW)
+            .readonly(CreateClaimData::getCrossBorderCountry1, NEVER_SHOW, true)
+            .readonly(CreateClaimData::getCrossBorderCountry2, NEVER_SHOW, true)
             .label("crossBorderPostcodeSelection-info", """
                 ---
                 <section tabindex="0">
@@ -61,16 +60,17 @@ public void addTo(PageBuilder pageBuilder) {
                 </div>
                 </section>
                 """)
-            .mandatory(PCSCase::getCrossBorderCountriesList,
+            .mandatory(CreateClaimData::getCrossBorderCountriesList,
                 null,
                 null,
                 "Is the property located in ${crossBorderCountry1} or ${crossBorderCountry2}?");
     }
 
-    private AboutToStartOrSubmitResponse<PCSCase, State> midEvent(CaseDetails<PCSCase, State> details,
-                                                                  CaseDetails<PCSCase, State> detailsBefore) {
+    private AboutToStartOrSubmitResponse<CreateClaimData, State> midEvent(
+        CaseDetails<CreateClaimData, State> details,
+        CaseDetails<CreateClaimData, State> detailsBefore) {
 
-        PCSCase caseData = details.getData();
+        CreateClaimData caseData = details.getData();
         String postcode = getPostcode(caseData);
 
         String countryCode = getSelectedCountryCode(caseData);
@@ -131,16 +131,16 @@ private AboutToStartOrSubmitResponse<PCSCase, State> midEvent(CaseDetails<PCSCas
         return response(caseData);
     }
 
-    private String getSelectedCountryCode(PCSCase caseData) {
+    private String getSelectedCountryCode(CreateClaimData caseData) {
         return caseData.getCrossBorderCountriesList().getValue().getCode();
     }
 
-    private String getPostcode(PCSCase caseData) {
+    private String getPostcode(CreateClaimData caseData) {
         return caseData.getPropertyAddress().getPostCode();
     }
 
-    private AboutToStartOrSubmitResponse<PCSCase, State> response(PCSCase caseData) {
-        return AboutToStartOrSubmitResponse.<PCSCase, State>builder()
+    private AboutToStartOrSubmitResponse<CreateClaimData, State> response(CreateClaimData caseData) {
+        return AboutToStartOrSubmitResponse.<CreateClaimData, State>builder()
             .data(caseData)
             .build();
     }