HDPI-3764: Add clearFields functionality to support field clearing in…

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

@@ -44,5 +44,8 @@ public class PossessionClaimResponse {
     @CCD(access = {CitizenAccess.class})
     private DefendantResponses defendantResponses;
 
+    @CCD(ignore = true)
+    private List<String> clearFields;
+
 }
 

src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/respondpossessionclaim/page/RespondToPossessionDraftSavePage.java

@@ -42,6 +42,7 @@ private AboutToStartOrSubmitResponse<PCSCase, State> midEvent(CaseDetails<PCSCas
         PossessionClaimResponse defendantAnswersOnly = PossessionClaimResponse.builder()
             .defendantContactDetails(response.getDefendantContactDetails())
             .defendantResponses(response.getDefendantResponses())
+            .clearFields(response.getClearFields())
             .build();
 
         PCSCase partialUpdate = PCSCase.builder()

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

@@ -1,7 +1,9 @@
 package uk.gov.hmcts.reform.pcs.ccd.service;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Service;
@@ -15,6 +17,7 @@
 import uk.gov.hmcts.reform.pcs.security.SecurityContextService;
 
 import java.io.IOException;
+import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.UUID;
@@ -85,17 +88,25 @@ public <T> void patchUnsubmittedEventData(long caseReference, T eventData, Event
         UUID userId = getCurrentUserId();
         log.info("Patching draft: caseReference={}, eventId={}, userId={}", caseReference, eventId, userId);
 
+        List<String> clearFields = extractClearFields(eventData);
         String patchEventDataJson = writeCaseDataJson(eventData);
-        patchUnsubmittedCaseData(caseReference, eventId, patchEventDataJson);
+        patchUnsubmittedCaseData(caseReference, eventId, patchEventDataJson, clearFields);
     }
 
-    public void patchUnsubmittedCaseData(long caseReference, EventId eventId, String patchEventDataJson) {
+    public void patchUnsubmittedCaseData(long caseReference, EventId eventId,
+                                          String patchEventDataJson, List<String> clearFields) {
         UUID userId = getCurrentUserId();
         DraftCaseDataEntity draftCaseDataEntity = draftCaseDataRepository
             .findByCaseReferenceAndEventIdAndIdamUserId(caseReference, eventId, userId)
             .map(existingDraft -> {
                 log.debug("Updating existing draft for userId={}", userId);
-                existingDraft.setCaseData(mergeCaseDataJson(existingDraft.getCaseData(), patchEventDataJson));
+                String mergedJson = mergeCaseDataJson(existingDraft.getCaseData(), patchEventDataJson);
+
+                if (clearFields != null && !clearFields.isEmpty()) {
+                    mergedJson = applyClearFieldsAndSerialize(mergedJson, clearFields);
+                }
+
+                existingDraft.setCaseData(mergedJson);
                 return existingDraft;
             }).orElseGet(() -> {
                 log.debug("Creating new draft for caseReference={}, eventId={}, userId={}",
@@ -158,4 +169,80 @@ private DraftCaseDataEntity createNewDraft(long caseReference, EventId eventId,
         return newDraft;
     }
 
+    private <T> List<String> extractClearFields(T eventData) {
+        if (eventData instanceof PCSCase) {
+            PCSCase pcsCase = (PCSCase) eventData;
+            if (pcsCase.getPossessionClaimResponse() != null) {
+                List<String> clearFields = pcsCase.getPossessionClaimResponse().getClearFields();
+                return clearFields != null ? clearFields : List.of();
+            }
+        }
+        return List.of();
+    }
+
+    private String applyClearFieldsAndSerialize(String mergedJson, List<String> clearFields) {
+        try {
+            ObjectNode root = parseJsonToTree(mergedJson);
+
+            clearFieldsFromPossessionClaimResponse(root, clearFields);
+            return serializeJsonTree(root);
+        } catch (JsonProcessingException e) {
+            log.error("Failed to apply clearFields", e);
+            throw new UnsubmittedDataException("Failed to clear fields", e);
+        }
+    }
+
+    private ObjectNode parseJsonToTree(String json) throws JsonProcessingException {
+        return (ObjectNode) objectMapper.readTree(json);
+    }
+
+    private void clearFieldsFromPossessionClaimResponse(ObjectNode root, List<String> clearFields) {
+        JsonNode pcrNode = root.at("/possessionClaimResponse");
+        if (!pcrNode.isObject()) {
+            return;
+        }
+
+        ObjectNode possessionClaimResponse = (ObjectNode) pcrNode;
+
+        for (String fieldPath : clearFields) {
+            removeField(possessionClaimResponse, fieldPath);
+        }
+
+        possessionClaimResponse.remove("clearFields");
+    }
+
+    private String serializeJsonTree(ObjectNode root) throws JsonProcessingException {
+        return objectMapper.writeValueAsString(root);
+    }
+
+    private void removeField(ObjectNode root, String fieldPath) {
+        String[] pathSegments = fieldPath.split("\\.");
+        ObjectNode parentNode = navigateToParentNode(root, pathSegments);
+
+        if (parentNode == null) {
+            return;
+        }
+
+        String fieldName = getFieldName(pathSegments);
+        parentNode.remove(fieldName);
+    }
+
+    private ObjectNode navigateToParentNode(ObjectNode root, String[] pathSegments) {
+        ObjectNode current = root;
+
+        for (int i = 0; i < pathSegments.length - 1; i++) {
+            JsonNode next = current.get(pathSegments[i]);
+            if (next == null || !next.isObject()) {
+                return null;
+            }
+            current = (ObjectNode) next;
+        }
+
+        return current;
+    }
+
+    private String getFieldName(String[] pathSegments) {
+        return pathSegments[pathSegments.length - 1];
+    }
+
 }