Hdpi 5213 confirm eviction update data model

src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/confirmeviction/EvictionEntity.java

@@ -0,0 +1,97 @@
+package uk.gov.hmcts.reform.pcs.ccd.entity.confirmeviction;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.OneToOne;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import org.hibernate.annotations.CreationTimestamp;
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+import uk.gov.hmcts.reform.pcs.ccd.domain.LanguageUsed;
+import uk.gov.hmcts.reform.pcs.ccd.domain.VerticalYesNo;
+import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity;
+import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.UnavailableDateEntity;
+
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+@Entity
+@Builder
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "enf_eviction")
+public class EvictionEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private UUID id;
+
+    @OneToOne
+    @JoinColumn(name = "enf_case_id", nullable = false)
+    private EnforcementOrderEntity enforcementOrder;
+
+    @Enumerated(EnumType.STRING)
+    @JdbcTypeCode(SqlTypes.NAMED_ENUM)
+    private VerticalYesNo evictionDateConfirmed;
+
+    @Enumerated(EnumType.STRING)
+    @JdbcTypeCode(SqlTypes.NAMED_ENUM)
+    private VerticalYesNo hasUnavailableDates;
+
+    @OneToMany(mappedBy = "eviction", cascade = CascadeType.ALL, orphanRemoval = true)
+    @Builder.Default
+    private List<UnavailableDateEntity> unavailableDates = new ArrayList<>();
+
+    private String beforeEvictionNameOrDepartment;
+
+    private String beforeEvictionTelephoneNumber;
+
+    private String beforeEvictionEmailAddress;
+
+    private String afterEvictionNameOrDepartment;
+
+    private String afterEvictionTelephoneNumber;
+
+    private String afterEvictionEmailAddress;
+
+    @Enumerated(EnumType.STRING)
+    @JdbcTypeCode(SqlTypes.NAMED_ENUM)
+    private VerticalYesNo difficultToAccess;
+
+    private String difficultToAccessDetails;
+
+    @Enumerated(EnumType.STRING)
+    @JdbcTypeCode(SqlTypes.NAMED_ENUM)
+    private VerticalYesNo anythingElse;
+
+    private String anythingElseDetails;
+
+    @Enumerated(EnumType.STRING)
+    @JdbcTypeCode(SqlTypes.NAMED_ENUM)
+    private VerticalYesNo confirmArrangementForAccess;
+
+    @Enumerated(EnumType.STRING)
+    private LanguageUsed languageUsed;
+
+    @CreationTimestamp
+    @Column(updatable = false, nullable = false)
+    private Instant created;
+
+}

src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/enforcetheorder/UnavailableDateEntity.java

@@ -0,0 +1,42 @@
+package uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder;
+
+import com.fasterxml.jackson.annotation.JsonBackReference;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import uk.gov.hmcts.reform.pcs.ccd.entity.confirmeviction.EvictionEntity;
+
+import java.time.LocalDate;
+import java.util.UUID;
+
+@Entity
+@Builder
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Table(name = "enf_unavailable_date")
+public class UnavailableDateEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private UUID id;
+
+    @ManyToOne
+    @JoinColumn(name = "enf_eviction_id", nullable = false)
+    @JsonBackReference
+    private EvictionEntity eviction;
+
+    private LocalDate unavailableDate;
+
+}
+

src/main/java/uk/gov/hmcts/reform/pcs/ccd/repository/enforcetheorder/EvictionRepository.java

@@ -0,0 +1,9 @@
+package uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import uk.gov.hmcts.reform.pcs.ccd.entity.confirmeviction.EvictionEntity;
+
+import java.util.UUID;
+
+public interface EvictionRepository extends JpaRepository<EvictionEntity, UUID> {
+}

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

@@ -9,8 +9,10 @@
 import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.SelectEnforcementType;
 import uk.gov.hmcts.reform.pcs.ccd.entity.ClaimEntity;
 import uk.gov.hmcts.reform.pcs.ccd.entity.PcsCaseEntity;
+import uk.gov.hmcts.reform.pcs.ccd.entity.confirmeviction.EvictionEntity;
 import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity;
 import uk.gov.hmcts.reform.pcs.ccd.event.EventId;
+import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.EvictionRepository;
 import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.EnforcementOrderRepository;
 import uk.gov.hmcts.reform.pcs.ccd.service.DraftCaseDataService;
 import uk.gov.hmcts.reform.pcs.ccd.service.PcsCaseService;
@@ -19,6 +21,8 @@
 import java.util.List;
 import java.util.Set;
 
+import static uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.SelectEnforcementType.getSelectEnforcementTypeFromName;
+
 @Service
 @Slf4j
 @AllArgsConstructor
@@ -28,15 +32,10 @@ public class EnforcementOrderService {
     private final PcsCaseService pcsCaseService;
     private final DraftCaseDataService draftCaseDataService;
     private final EnforcementTypeStrategyFactory strategyFactory;
+    private final EvictionRepository evictionRepository;
 
     public EnforcementOrder retrieveEnforcementOrder(long caseReference, SelectEnforcementType enforcementType) {
-        PcsCaseEntity pcsCaseEntity = pcsCaseService.loadCase(caseReference);
-        ClaimEntity claimEntity = retrieveClaimEntity(pcsCaseEntity);
-        Set<EnforcementOrderEntity> enforcementEntitySet = claimEntity.getEnforcementOrders();
-        if (CollectionUtils.isEmpty(enforcementEntitySet)) {
-            return null;
-        }
-
+        Set<EnforcementOrderEntity> enforcementEntitySet = getEnforcementOrderEntities(caseReference);
         return enforcementEntitySet
                 .stream()
                 .map(EnforcementOrderEntity::getEnforcementOrder)
@@ -46,9 +45,23 @@ public EnforcementOrder retrieveEnforcementOrder(long caseReference, SelectEnfor
                 .orElse(null);
     }
 
+    Set<EnforcementOrderEntity> getEnforcementOrderEntities(long caseReference) {
+        PcsCaseEntity pcsCaseEntity = pcsCaseService.loadCase(caseReference);
+        ClaimEntity claimEntity = retrieveClaimEntity(pcsCaseEntity);
+        if (claimEntity == null) {
+            log.debug("No claim entities found for PCS case when retrieving enforcement order for caseReference={}",
+                      caseReference
+            );
+            return Set.of();
+        }
+        return claimEntity.getEnforcementOrders();
+    }
+
     ClaimEntity retrieveClaimEntity(PcsCaseEntity pcsCaseEntity) {
         List<ClaimEntity> claimEntities = pcsCaseEntity.getClaims();
-
+        if (CollectionUtils.isEmpty(claimEntities)) {
+            return null;
+        }
         // Assuming 1 claim per PcsCase
         return claimEntities.getFirst();
     }
@@ -60,15 +73,44 @@ public void saveAndClearDraftData(long caseReference, EnforcementOrder enforceme
     }
 
     private void createEnforcementOrder(long caseReference, EnforcementOrder enforcementOrder) {
+        ClaimEntity claimEntity = getClaimEntity(caseReference);
+        EnforcementOrderEntity orderEntity = enforcementOrderRepository
+            .save(mapToEntity(enforcementOrder, claimEntity));
+        strategyFactory.getStrategy(getSelectEnforcementTypeFromName(
+            enforcementOrder.getChooseEnforcementType().getValueCode()))
+            .process(orderEntity, enforcementOrder);
+    }
+
+    private ClaimEntity getClaimEntity(long caseReference) {
         PcsCaseEntity pcsCaseEntity = pcsCaseService.loadCase(caseReference);
+        List<ClaimEntity> claimEntities = pcsCaseEntity.getClaims();
+        if (CollectionUtils.isEmpty(claimEntities)) {
+            throw new IllegalStateException("Cannot create enforcement order because no claim entity exists for "
+                                                + "caseReference=" + caseReference);
+        }
+        // Assuming 1 claim per PcsCase
+        return claimEntities.getFirst();
+    }
 
-        ClaimEntity claimEntity = retrieveClaimEntity(pcsCaseEntity);
+    public void confirmEviction(long caseReference) {
+        EvictionEntity confirmEviction = mapToConfirmEvictionEntity(caseReference);
+        evictionRepository.save(confirmEviction);
+    }
 
-        EnforcementOrderEntity orderEntity = enforcementOrderRepository
-            .save(mapToEntity(enforcementOrder, claimEntity));
-        strategyFactory.getStrategy(SelectEnforcementType.getSelectEnforcementTypeFromName(
-                        enforcementOrder.getChooseEnforcementType().getValueCode()))
-                .process(orderEntity, enforcementOrder);
+    private EvictionEntity mapToConfirmEvictionEntity(long caseReference) {
+        EvictionEntity confirmEviction = new EvictionEntity();
+        EnforcementOrderEntity enforcementOrderEntity = retrieveEnforcementOrderEntity(caseReference);
+        confirmEviction.setEnforcementOrder(enforcementOrderEntity);
+
+        return confirmEviction;
+    }
+
+    private EnforcementOrderEntity retrieveEnforcementOrderEntity(long caseReference) {
+        Set<EnforcementOrderEntity> enforcementOrders = getEnforcementOrderEntities(caseReference);
+        if (enforcementOrders.isEmpty()) {
+            return null;
+        }
+        return enforcementOrders.stream().findFirst().orElse(null);
     }
 
     private EnforcementOrderEntity mapToEntity(EnforcementOrder enforcementOrder, ClaimEntity claimEntity) {

src/main/resources/db/migration/V075__enforcement_confirm_eviction.sql

@@ -0,0 +1,49 @@
+CREATE TABLE enf_eviction(
+  id                                                      UUID PRIMARY KEY,
+  enf_case_id                                             UUID NOT NULL REFERENCES enf_case (id) ON DELETE CASCADE,
+
+  -- The eviction date
+  eviction_date_confirmed                                 YES_NO NOT NULL,
+
+  -- Dates when you can not attend an eviction
+  has_unavailable_dates                                    YES_NO NOT NULL,
+
+  -- separate table for dates unavailable table
+
+  -- Contact for Bailiff
+  before_eviction_name_or_department                        VARCHAR(100),
+  before_eviction_telephone_number                          VARCHAR(20),
+  before_eviction_email_address                             VARCHAR(60),
+
+  after_eviction_name_or_department                         VARCHAR(100),
+  after_eviction_telephone_number                           VARCHAR(20),
+  after_eviction_email_address                              VARCHAR(60),
+
+  -- access to the property
+  difficult_to_access                                       YES_NO,
+  difficult_to_access_details                               VARCHAR(6800),
+
+  -- Anything else that could help with the eviction
+  anything_else                                              YES_NO,
+  anything_else_details                                      VARCHAR(6800),
+
+  -- Gaining access to and securing the property after the eviction
+  confirm_arrangement_for_access                              YES_NO,
+
+  language_used                                               VARCHAR(30),
+  created                                                     TIMESTAMP WITHOUT TIME ZONE NOT NULL,
+
+  CONSTRAINT unique_confirm_eviction_per_enforcement UNIQUE(enf_case_id)
+);
+
+ALTER TABLE enf_risk_profile
+  ADD COLUMN physical_description_of_risk_defendant YES_NO;
+
+ALTER TABLE enf_risk_profile
+  ADD COLUMN physical_description_of_risk_defendant_details VARCHAR(6800);
+
+CREATE TABLE enf_unavailable_date (
+  id                                                   UUID PRIMARY KEY,
+  enf_eviction_id                                      UUID NOT NULL REFERENCES enf_eviction (id) ON DELETE CASCADE,
+  unavailable_date                                     DATE NOT NULL
+);