diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/DocumentType.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/DocumentType.java index d3fd6fc7b9..964c3c163b 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/DocumentType.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/DocumentType.java @@ -24,6 +24,7 @@ public enum DocumentType implements HasLabel { INSPECTION_OR_REPORT("Inspection or report"), CERTIFICATE_OF_SUITABILITY_AS_LF("Certificate of suitability as litigation friend"), LEGAL_AID_CERTIFICATE("Legal aid certificate"), + POLICE_REPORT("Police report"), OTHER("Other document"); private final String label; diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/enforcetheorder/warrantofrestitution/WarrantOfRestitutionDetails.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/enforcetheorder/warrantofrestitution/WarrantOfRestitutionDetails.java index cfe0e9f5b7..69a4589fdb 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/enforcetheorder/warrantofrestitution/WarrantOfRestitutionDetails.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/domain/enforcetheorder/warrantofrestitution/WarrantOfRestitutionDetails.java @@ -75,5 +75,4 @@ public class WarrantOfRestitutionDetails { @JsonUnwrapped @CCD private AdditionalInformation additionalInformation; - } diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/DocumentEntity.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/DocumentEntity.java index 558fb82a10..4b80a4d5c9 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/DocumentEntity.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/DocumentEntity.java @@ -18,6 +18,7 @@ import lombok.NoArgsConstructor; import lombok.Setter; import uk.gov.hmcts.reform.pcs.ccd.domain.DocumentType; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; import java.util.ArrayList; import java.util.List; @@ -58,4 +59,9 @@ public class DocumentEntity { @Builder.Default @JsonManagedReference private List claimDocuments = new ArrayList<>(); + + @ManyToOne(fetch = LAZY) + @JoinColumn(name = "enf_case_id") + @JsonBackReference + private EnforcementOrderEntity enfCase; } diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/claim/StatementOfTruthEntity.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/claim/StatementOfTruthEntity.java index ad74aeef74..13eef35248 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/claim/StatementOfTruthEntity.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/claim/StatementOfTruthEntity.java @@ -1,6 +1,7 @@ package uk.gov.hmcts.reform.pcs.ccd.entity.claim; import com.fasterxml.jackson.annotation.JsonBackReference; +import com.fasterxml.jackson.annotation.JsonManagedReference; import jakarta.persistence.Entity; import jakarta.persistence.EnumType; import jakarta.persistence.Enumerated; @@ -19,6 +20,7 @@ import uk.gov.hmcts.ccd.sdk.type.YesOrNo; import uk.gov.hmcts.reform.pcs.ccd.domain.statementoftruth.StatementOfTruthCompletedBy; import uk.gov.hmcts.reform.pcs.ccd.entity.ClaimEntity; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.respondpossessionclaim.DefendantResponseEntity; import java.util.UUID; @@ -44,6 +46,10 @@ public class StatementOfTruthEntity { @JsonBackReference private DefendantResponseEntity defendantResponse; + @OneToOne(mappedBy = "statementOfTruth") + @JsonManagedReference + private EnforcementOrderEntity enforcementOrder; + @Enumerated(EnumType.STRING) private StatementOfTruthCompletedBy completedBy; diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/enforcetheorder/EnforcementOrderEntity.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/enforcetheorder/EnforcementOrderEntity.java index 3a90601007..994a85814f 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/enforcetheorder/EnforcementOrderEntity.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/enforcetheorder/EnforcementOrderEntity.java @@ -1,6 +1,7 @@ package uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder; import com.fasterxml.jackson.annotation.JsonBackReference; +import com.fasterxml.jackson.annotation.JsonManagedReference; import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.GeneratedValue; @@ -8,23 +9,35 @@ import jakarta.persistence.Id; import jakarta.persistence.JoinColumn; import jakarta.persistence.ManyToOne; +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.JdbcTypeCode; import org.hibernate.type.SqlTypes; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; import uk.gov.hmcts.reform.pcs.ccd.entity.ClaimEntity; +import uk.gov.hmcts.reform.pcs.ccd.entity.DocumentEntity; +import uk.gov.hmcts.reform.pcs.ccd.entity.claim.StatementOfTruthEntity; +import java.util.ArrayList; +import java.util.List; import java.util.UUID; +import static jakarta.persistence.CascadeType.ALL; import static jakarta.persistence.FetchType.LAZY; @Entity @Table(name = "enf_case") @Getter @Setter +@Builder +@NoArgsConstructor +@AllArgsConstructor public class EnforcementOrderEntity { @Id @@ -40,7 +53,26 @@ public class EnforcementOrderEntity { @Column(name = "enforcement_order") private EnforcementOrder enforcementOrder; - @OneToOne(mappedBy = "enforcementOrder", fetch = LAZY) + @OneToOne(mappedBy = "enforcementOrder") private WarrantEntity warrantDetails; + @OneToOne(mappedBy = "enforcementOrder") + private WarrantOfRestitutionEntity warrantOfRestitutionDetails; + + @OneToOne(fetch = LAZY) + @JoinColumn(name = "sot_id", nullable = false) + @JsonBackReference + private StatementOfTruthEntity statementOfTruth; + + @OneToMany(mappedBy = "enfCase", fetch = LAZY, cascade = ALL, orphanRemoval = true) + @Builder.Default + @JsonManagedReference + private List documents = new ArrayList<>(); + + public void addDocuments(List documents) { + for (DocumentEntity document : documents) { + document.setEnfCase(this); + this.documents.add(document); + } + } } diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/enforcetheorder/WarrantOfRestitutionEntity.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/enforcetheorder/WarrantOfRestitutionEntity.java index b627d5b71d..ca47e4d765 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/enforcetheorder/WarrantOfRestitutionEntity.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/entity/enforcetheorder/WarrantOfRestitutionEntity.java @@ -11,18 +11,27 @@ import jakarta.persistence.JoinColumn; 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 java.time.Instant; import java.util.UUID; @Entity +@Builder @Table(name = "enf_warrant_of_restitution") @Getter @Setter +@NoArgsConstructor +@AllArgsConstructor public class WarrantOfRestitutionEntity { @Id @@ -34,6 +43,23 @@ public class WarrantOfRestitutionEntity { @JsonBackReference private EnforcementOrderEntity enforcementOrder; + // Defendants Returned + private String howDefendantsReturned; + + // Additional Information + @Enumerated(EnumType.STRING) + @JdbcTypeCode(SqlTypes.NAMED_ENUM) + private VerticalYesNo additionalInformationSelect; + + private String additionalInformationDetails; + + // PropertyAccessDetails + @Enumerated(EnumType.STRING) + @JdbcTypeCode(SqlTypes.NAMED_ENUM) + private VerticalYesNo isDifficultToAccessProperty; + + private String clarificationOnAccessDifficultyText; + @Enumerated(EnumType.STRING) private LanguageUsed languageUsed; diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/PeopleWhoWillBeEvictedWarrantRestPlaceholder.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/PeopleWhoWillBeEvictedWarrantRestPlaceholder.java deleted file mode 100644 index a8b752ad02..0000000000 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/PeopleWhoWillBeEvictedWarrantRestPlaceholder.java +++ /dev/null @@ -1,20 +0,0 @@ -package uk.gov.hmcts.reform.pcs.ccd.page.enforcetheorder.warrantofrestitution; - -import uk.gov.hmcts.reform.pcs.ccd.common.CcdPageConfiguration; -import uk.gov.hmcts.reform.pcs.ccd.common.PageBuilder; - -import static uk.gov.hmcts.reform.pcs.ccd.page.CommonPageContent.SAVE_AND_RETURN; -import static uk.gov.hmcts.reform.pcs.ccd.page.enforcetheorder.ShowConditionsEnforcementType.WARRANT_OF_RESTITUTION_FLOW; - -public class PeopleWhoWillBeEvictedWarrantRestPlaceholder implements CcdPageConfiguration { - - @Override - public void addTo(PageBuilder pageBuilder) { - pageBuilder - .page("peopleWhoWillBeEvictedWarrantRestitution") - .pageLabel("The people who will be evicted (placeholder)") - .showCondition(WARRANT_OF_RESTITUTION_FLOW) - .label("peopleWhoWillBeEvictedWarrantRestitution-line-separator", "---") - .label("peopleWhoWillBeEvictedWarrantRestitution-save-and-return", SAVE_AND_RETURN); - } -} diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/PropertyAccessDetailsWarrantRestPlaceholder.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/PeopleYouWantToEvictWarrantRestPlaceholder.java similarity index 59% rename from src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/PropertyAccessDetailsWarrantRestPlaceholder.java rename to src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/PeopleYouWantToEvictWarrantRestPlaceholder.java index d01ffe654e..c0c6fb1220 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/PropertyAccessDetailsWarrantRestPlaceholder.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/PeopleYouWantToEvictWarrantRestPlaceholder.java @@ -6,15 +6,15 @@ import static uk.gov.hmcts.reform.pcs.ccd.page.CommonPageContent.SAVE_AND_RETURN; import static uk.gov.hmcts.reform.pcs.ccd.page.enforcetheorder.ShowConditionsEnforcementType.WARRANT_OF_RESTITUTION_FLOW; -public class PropertyAccessDetailsWarrantRestPlaceholder implements CcdPageConfiguration { +public class PeopleYouWantToEvictWarrantRestPlaceholder implements CcdPageConfiguration { @Override public void addTo(PageBuilder pageBuilder) { pageBuilder - .page("propertyAccessDetailsRest") - .pageLabel("Access to the property (Placeholder)") + .page("peopleYouWantToEvictWarrantRest") + .pageLabel("The people you want to evict (placeholder)") .showCondition(WARRANT_OF_RESTITUTION_FLOW) - .label("propertyAccessDetailsRest-line-separator", "---") - .label("propertyAccessDetailsRest-saveAndReturn", SAVE_AND_RETURN); + .label("peopleYouWantToEvictWarrantRest-line-separator", "---") + .label("peopleYouWantToEvictWarrantRest-save-and-return", SAVE_AND_RETURN); } -} \ No newline at end of file +} diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/WarrantOfRestitutionPageConfigurer.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/WarrantOfRestitutionPageConfigurer.java index f08c265637..700b5707d1 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/WarrantOfRestitutionPageConfigurer.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/WarrantOfRestitutionPageConfigurer.java @@ -16,7 +16,7 @@ public class WarrantOfRestitutionPageConfigurer implements PageConfigurer { @Override public void configurePages(PageBuilder pageBuilder) { pageBuilder - .add(new PeopleWhoWillBeEvictedWarrantRestPlaceholder()) + .add(new PeopleYouWantToEvictWarrantRestPlaceholder()) .add(new ShareEvidenceWithJudgePage()) .add(explainHowDefendantsReturnedPage) .add(new DefendantAtPropertyPage()) diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/DocumentService.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/DocumentService.java index 707fcfea1c..c29f455f16 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/DocumentService.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/DocumentService.java @@ -3,6 +3,7 @@ import lombok.AllArgsConstructor; import org.apache.commons.lang3.tuple.Pair; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; import uk.gov.hmcts.ccd.sdk.type.Document; import uk.gov.hmcts.ccd.sdk.type.ListValue; import uk.gov.hmcts.reform.pcs.ccd.domain.AdditionalDocument; @@ -12,6 +13,9 @@ import uk.gov.hmcts.reform.pcs.ccd.domain.PCSCase; import uk.gov.hmcts.reform.pcs.ccd.domain.RentArrearsSection; import uk.gov.hmcts.reform.pcs.ccd.domain.TenancyLicenceDetails; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.EvidenceDocumentType; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.EvidenceOfDefendants; import uk.gov.hmcts.reform.pcs.ccd.domain.wales.OccupationLicenceDetailsWales; import uk.gov.hmcts.reform.pcs.ccd.entity.DocumentEntity; import uk.gov.hmcts.reform.pcs.ccd.repository.DocumentRepository; @@ -31,37 +35,56 @@ public class DocumentService { public List createAllDocuments(PCSCase pcsCase) { + List> allDocuments = getPcsCaseDocuments(pcsCase); + + return documentRepository.saveAll(createDocumentEntities(allDocuments)); + } + + public List createAllDocuments(EnforcementOrder enforcementOrder) { + + List> allDocuments = getWarrantOfRestitutionDocuments(enforcementOrder); + + return documentRepository.saveAll(createDocumentEntities(allDocuments)); + } + + private List> getPcsCaseDocuments(PCSCase pcsCase) { List> allDocuments = new ArrayList<>(); allDocuments.addAll(mapAdditionalDocumentsWithType(pcsCase.getAdditionalDocuments())); allDocuments.addAll(mapDocumentsWithType( Optional.ofNullable(pcsCase.getRentArrears()) - .map(RentArrearsSection::getStatementDocuments) - .orElse(null), DocumentType.RENT_STATEMENT)); + .map(RentArrearsSection::getStatementDocuments) + .orElse(null), DocumentType.RENT_STATEMENT)); allDocuments.addAll(mapDocumentsWithType( Optional.ofNullable(pcsCase.getTenancyLicenceDetails()) - .map(TenancyLicenceDetails::getTenancyLicenceDocuments) - .orElse(null), DocumentType.TENANCY_LICENCE)); + .map(TenancyLicenceDetails::getTenancyLicenceDocuments) + .orElse(null), DocumentType.TENANCY_LICENCE)); allDocuments.addAll(mapDocumentsWithType( Optional.ofNullable(pcsCase.getOccupationLicenceDetailsWales()) - .map(OccupationLicenceDetailsWales::getLicenceDocuments) - .orElse(null), DocumentType.OCCUPATION_LICENCE)); + .map(OccupationLicenceDetailsWales::getLicenceDocuments) + .orElse(null), DocumentType.OCCUPATION_LICENCE)); allDocuments.addAll(mapDocumentsWithType( Optional.ofNullable(pcsCase.getNoticeServedDetails()) - .map(NoticeServedDetails::getNoticeDocuments) - .orElse(null), DocumentType.NOTICE_SERVED)); + .map(NoticeServedDetails::getNoticeDocuments) + .orElse(null), DocumentType.NOTICE_SERVED)); - return documentRepository.saveAll(createDocumentEntities(allDocuments)); + return allDocuments; + } + + private List> getWarrantOfRestitutionDocuments(EnforcementOrder enforcementOrder) { + + return new ArrayList<>(mapEvidenceOfDefendantsDocumentsWithType( + enforcementOrder.getWarrantOfRestitutionDetails().getAdditionalDocuments())); } private List> mapDocumentsWithType( List> docs, DocumentType type) { - if (docs == null || docs.isEmpty()) { + if (CollectionUtils.isEmpty(docs)) { return Collections.emptyList(); } @@ -75,7 +98,7 @@ private List> mapDocumentsWithType( private List> mapAdditionalDocumentsWithType( List> documents) { - if (documents == null || documents.isEmpty()) { + if (CollectionUtils.isEmpty(documents)) { return Collections.emptyList(); } @@ -87,10 +110,25 @@ private List> mapAdditionalDocumentsWithType( .toList(); } + private List> mapEvidenceOfDefendantsDocumentsWithType( + List> documents) { + + if (CollectionUtils.isEmpty(documents)) { + return Collections.emptyList(); + } + + return ListValueUtils.unwrapListItems(documents).stream() + .map(doc -> Pair.of( + doc.getDocument(), + mapEvidenceDocumentTypeToDocumentType(doc.getDocumentType()) + )) + .toList(); + } + private List createDocumentEntities( List> documents) { - if (documents == null || documents.isEmpty()) { + if (CollectionUtils.isEmpty(documents)) { return List.of(); } @@ -122,4 +160,13 @@ private DocumentType mapAdditionalDocumentTypeToDocumentType(AdditionalDocumentT case OTHER -> DocumentType.OTHER; }; } + + private DocumentType mapEvidenceDocumentTypeToDocumentType(EvidenceDocumentType evidenceDocumentType) { + return switch (evidenceDocumentType) { + case PHOTOGRAPHIC_EVIDENCE -> DocumentType.PHOTOGRAPHIC_EVIDENCE; + case POLICE_REPORT -> DocumentType.POLICE_REPORT; + case WITNESS_STATEMENT -> DocumentType.WITNESS_STATEMENT; + case OTHER -> DocumentType.OTHER; + }; + } } diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/StatementOfTruthService.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/StatementOfTruthService.java index 27cfe34cec..5e97e5139d 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/StatementOfTruthService.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/StatementOfTruthService.java @@ -59,4 +59,3 @@ private static boolean legalRepAgreed(StatementOfTruthDetails statementOfTruth) .orElse(false); } } - diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/EnforcementOrderService.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/EnforcementOrderService.java index b54a25ac9d..c574e34796 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/EnforcementOrderService.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/EnforcementOrderService.java @@ -64,11 +64,11 @@ private void createEnforcementOrder(long caseReference, EnforcementOrder enforce ClaimEntity claimEntity = retrieveClaimEntity(pcsCaseEntity); - EnforcementOrderEntity orderEntity = enforcementOrderRepository + EnforcementOrderEntity savedEntity = enforcementOrderRepository .save(mapToEntity(enforcementOrder, claimEntity)); strategyFactory.getStrategy(SelectEnforcementType.getSelectEnforcementTypeFromName( enforcementOrder.getChooseEnforcementType().getValueCode())) - .process(orderEntity, enforcementOrder); + .process(savedEntity, enforcementOrder); } private EnforcementOrderEntity mapToEntity(EnforcementOrder enforcementOrder, ClaimEntity claimEntity) { @@ -77,5 +77,4 @@ private EnforcementOrderEntity mapToEntity(EnforcementOrder enforcementOrder, Cl enforcementOrderEntity.setEnforcementOrder(enforcementOrder); return enforcementOrderEntity; } - } diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/RiskProfileService.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/RiskProfileService.java new file mode 100644 index 0000000000..e849a0d052 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/RiskProfileService.java @@ -0,0 +1,24 @@ +package uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder; + +import lombok.AllArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.RiskProfileEntity; +import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.RiskProfileRepository; +import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper.RiskDetailsMapper; + +@Service +@Slf4j +@AllArgsConstructor +public class RiskProfileService { + + private final RiskDetailsMapper riskProfileMapper; + private final RiskProfileRepository riskProfileRepository; + + public void processRisk(EnforcementOrder enforcementOrder, EnforcementOrderEntity enforcementOrderEntity) { + RiskProfileEntity riskProfile = riskProfileMapper.toEntity(enforcementOrderEntity, enforcementOrder); + riskProfileRepository.save(riskProfile); + } +} diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/RiskDetailsMapper.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/RiskDetailsMapper.java index 828ee86e90..6a4b8c11c8 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/RiskDetailsMapper.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/RiskDetailsMapper.java @@ -3,9 +3,12 @@ import org.modelmapper.ModelMapper; import org.springframework.stereotype.Component; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.SelectEnforcementType; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.RiskDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.RawWarrantDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.WarrantDetails; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.RawWarrantRestDetails; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.WarrantOfRestitutionDetails; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.RiskProfileEntity; @@ -22,18 +25,35 @@ public RiskProfileEntity toEntity(EnforcementOrderEntity enforcementOrderEntity, EnforcementOrder enforcementOrder) { RiskProfileEntity riskProfileEntity = new RiskProfileEntity(); riskProfileEntity.setEnforcementOrder(enforcementOrderEntity); - WarrantDetails warrantDetails = enforcementOrder.getWarrantDetails(); + + SelectEnforcementType enforcementType = + SelectEnforcementType.getSelectEnforcementTypeFromName( + enforcementOrder.getChooseEnforcementType().getValueCode()); + switch (enforcementType) { + case WARRANT -> { + applyWarrantDetails(enforcementOrder.getWarrantDetails(), riskProfileEntity); + applyRawWarrantDetails(enforcementOrder.getRawWarrantDetails(), riskProfileEntity); + } + case WARRANT_OF_RESTITUTION -> { + applyWarrantOfRestitutionDetails(enforcementOrder.getWarrantOfRestitutionDetails(), riskProfileEntity); + applyRawWarrantRestDetails(enforcementOrder.getRawWarrantRestDetails(), riskProfileEntity); + } + default -> { + } // Not needed for other enforcement types + } + return riskProfileEntity; + } + + private void applyWarrantDetails(WarrantDetails warrantDetails, RiskProfileEntity riskProfileEntity) { riskProfileEntity.setAnyRiskToBailiff(warrantDetails.getAnyRiskToBailiff()); + RiskDetails riskDetails = warrantDetails.getRiskDetails(); if (riskDetails != null) { modelMapper.map(riskDetails, riskProfileEntity); } - applyRawWarrantDetails(enforcementOrder, riskProfileEntity); - return riskProfileEntity; } - private void applyRawWarrantDetails(EnforcementOrder enforcementOrder, RiskProfileEntity entity) { - RawWarrantDetails rawWarrantDetails = enforcementOrder.getRawWarrantDetails(); + private void applyRawWarrantDetails(RawWarrantDetails rawWarrantDetails, RiskProfileEntity entity) { if (rawWarrantDetails != null) { entity.setVulnerablePeoplePresent(rawWarrantDetails.getVulnerablePeoplePresent()); if (rawWarrantDetails.getVulnerableAdultsChildren() != null) { @@ -44,4 +64,26 @@ private void applyRawWarrantDetails(EnforcementOrder enforcementOrder, RiskProfi } } } + + private void applyWarrantOfRestitutionDetails(WarrantOfRestitutionDetails details, + RiskProfileEntity riskProfileEntity) { + riskProfileEntity.setAnyRiskToBailiff(details.getAnyRiskToBailiff()); + + RiskDetails riskDetails = details.getRiskDetails(); + if (riskDetails != null) { + modelMapper.map(riskDetails, riskProfileEntity); + } + } + + private void applyRawWarrantRestDetails(RawWarrantRestDetails details, RiskProfileEntity entity) { + if (details != null) { + entity.setVulnerablePeoplePresent(details.getVulnerablePeoplePresentWarrantRest()); + if (details.getVulnerableAdultsChildrenWarrantRest() != null) { + entity.setVulnerableCategory( + details.getVulnerableAdultsChildrenWarrantRest().getVulnerableCategory()); + entity.setVulnerableReasonText( + details.getVulnerableAdultsChildrenWarrantRest().getVulnerableReasonText()); + } + } + } } diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/WarrantOfRestitutionMapper.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/WarrantOfRestitutionMapper.java index a88caf5175..8bc0cd9ed7 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/WarrantOfRestitutionMapper.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/WarrantOfRestitutionMapper.java @@ -11,6 +11,8 @@ import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.RiskDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.PropertyAccessDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.RiskCategory; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.WarrantOfRestitutionEntity; import java.util.HashSet; import java.util.Set; @@ -75,4 +77,42 @@ public void prePopulateFieldsFromWarrantDetails(EnforcementOrder warrantEnforcem currentEnfOrder.setRawWarrantRestDetails(rawWarrantRestDetails); } + + public WarrantOfRestitutionEntity toEntity(EnforcementOrder enforcementOrder, + EnforcementOrderEntity enforcementOrderEntity) { + WarrantOfRestitutionEntity warrantOfRestitutionEntity = WarrantOfRestitutionEntity.builder() + .enforcementOrder(enforcementOrderEntity).build(); + if (enforcementOrder.getWarrantOfRestitutionDetails() != null) { + WarrantOfRestitutionDetails warrantOfRestitutionDetails = enforcementOrder.getWarrantOfRestitutionDetails(); + mapDefendantReturned(warrantOfRestitutionEntity, warrantOfRestitutionDetails); + mapAdditionalInformation(warrantOfRestitutionEntity, warrantOfRestitutionDetails); + mapPropertyAccessDetails(warrantOfRestitutionEntity, warrantOfRestitutionDetails); + } + return warrantOfRestitutionEntity; + } + + private void mapDefendantReturned(WarrantOfRestitutionEntity warrantOfRestitutionEntity, + WarrantOfRestitutionDetails warrantOfRestitutionDetails) { + warrantOfRestitutionEntity.setHowDefendantsReturned(warrantOfRestitutionDetails.getHowDefendantsReturned()); + } + + private void mapAdditionalInformation(WarrantOfRestitutionEntity warrantOfRestitutionEntity, + WarrantOfRestitutionDetails warrantOfRestitutionDetails) { + if (warrantOfRestitutionDetails.getAdditionalInformation() != null) { + warrantOfRestitutionEntity.setAdditionalInformationSelect( + warrantOfRestitutionDetails.getAdditionalInformation().getAdditionalInformationSelect()); + warrantOfRestitutionEntity.setAdditionalInformationDetails( + warrantOfRestitutionDetails.getAdditionalInformation().getAdditionalInformationDetails()); + } + } + + private void mapPropertyAccessDetails(WarrantOfRestitutionEntity warrantOfRestitutionEntity, + WarrantOfRestitutionDetails warrantOfRestitutionDetails) { + if (warrantOfRestitutionDetails.getPropertyAccessDetails() != null) { + warrantOfRestitutionEntity.setIsDifficultToAccessProperty( + warrantOfRestitutionDetails.getPropertyAccessDetails().getIsDifficultToAccessProperty()); + warrantOfRestitutionEntity.setClarificationOnAccessDifficultyText( + warrantOfRestitutionDetails.getPropertyAccessDetails().getClarificationOnAccessDifficultyText()); + } + } } diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantOfRestitutionStrategy.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantOfRestitutionStrategy.java index cd90278639..dde754ea2c 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantOfRestitutionStrategy.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantOfRestitutionStrategy.java @@ -2,21 +2,51 @@ import lombok.AllArgsConstructor; import org.springframework.stereotype.Component; +import org.springframework.util.CollectionUtils; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; +import uk.gov.hmcts.reform.pcs.ccd.entity.DocumentEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.WarrantOfRestitutionEntity; +import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.EnforcementOrderRepository; import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.WarrantOfRestitutionRepository; +import uk.gov.hmcts.reform.pcs.ccd.service.DocumentService; +import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.RiskProfileService; +import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper.WarrantOfRestitutionMapper; + +import java.util.List; @Component @AllArgsConstructor public class WarrantOfRestitutionStrategy implements EnforcementTypeStrategy { + private final RiskProfileService riskProfileService; + private final WarrantOfRestitutionMapper warrantOfRestitutionMapper; private final WarrantOfRestitutionRepository warrantOfRestitutionRepository; + private final EnforcementOrderRepository enforcementOrderRepository; + private final DocumentService documentService; @Override public void process(EnforcementOrderEntity enforcementOrderEntity, EnforcementOrder enforcementOrder) { - WarrantOfRestitutionEntity warrantOfRestitutionEntity = new WarrantOfRestitutionEntity(); - warrantOfRestitutionEntity.setEnforcementOrder(enforcementOrderEntity); - warrantOfRestitutionRepository.save(warrantOfRestitutionEntity); + riskProfileService.processRisk(enforcementOrder, enforcementOrderEntity); + processWarrantOfRestitution(enforcementOrder, enforcementOrderEntity); + processDocuments(enforcementOrder, enforcementOrderEntity); + } + + private void processWarrantOfRestitution(EnforcementOrder enforcementOrder, + EnforcementOrderEntity enforcementOrderEntity) { + WarrantOfRestitutionEntity warrantOfRestitutionEntity = warrantOfRestitutionMapper.toEntity(enforcementOrder, + enforcementOrderEntity); + WarrantOfRestitutionEntity saved = warrantOfRestitutionRepository.save(warrantOfRestitutionEntity); + enforcementOrderEntity.setWarrantOfRestitutionDetails(saved); + } + + private void processDocuments(EnforcementOrder enforcementOrder, EnforcementOrderEntity enforcementOrderEntity) { + if (enforcementOrder.getWarrantOfRestitutionDetails() != null + && !CollectionUtils.isEmpty( + enforcementOrder.getWarrantOfRestitutionDetails().getAdditionalDocuments())) { + List documentEntities = documentService.createAllDocuments(enforcementOrder); + enforcementOrderEntity.addDocuments(documentEntities); + enforcementOrderRepository.save(enforcementOrderEntity); + } } } diff --git a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantStrategy.java b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantStrategy.java index 8027f6cbd0..9930f71126 100644 --- a/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantStrategy.java +++ b/src/main/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantStrategy.java @@ -6,12 +6,10 @@ import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.WarrantEntity; -import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.RiskProfileEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.SelectedDefendantEntity; -import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.RiskProfileRepository; import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.SelectedDefendantRepository; +import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.RiskProfileService; import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper.WarrantDetailsMapper; -import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper.RiskDetailsMapper; import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper.SelectedDefendantsMapper; import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.WarrantRepository; @@ -21,17 +19,17 @@ @AllArgsConstructor public class WarrantStrategy implements EnforcementTypeStrategy { - private final RiskProfileRepository riskProfileRepository; + private final RiskProfileService riskProfileService; private final SelectedDefendantsMapper selectedDefendantsMapper; private final SelectedDefendantRepository selectedDefendantRepository; private final WarrantDetailsMapper warrantDetailsMapper; - private final RiskDetailsMapper riskProfileMapper; + private final WarrantRepository warrantRepository; @Override public void process(EnforcementOrderEntity enforcementOrderEntity, EnforcementOrder enforcementOrder) { processWarrant(enforcementOrder, enforcementOrderEntity); - processRisk(enforcementOrder, enforcementOrderEntity); + riskProfileService.processRisk(enforcementOrder, enforcementOrderEntity); processSelectedDefendants(enforcementOrderEntity); } @@ -42,11 +40,6 @@ private void processWarrant(EnforcementOrder enforcementOrder, EnforcementOrderE enforcementOrderEntity.setWarrantDetails(saved); } - private void processRisk(EnforcementOrder enforcementOrder, EnforcementOrderEntity enforcementOrderEntity) { - RiskProfileEntity riskProfile = riskProfileMapper.toEntity(enforcementOrderEntity, enforcementOrder); - riskProfileRepository.save(riskProfile); - } - private void processSelectedDefendants(EnforcementOrderEntity enforcementOrderEntity) { List selectedDefendantsEntities = selectedDefendantsMapper.mapToEntities(enforcementOrderEntity); diff --git a/src/main/resources/db/migration/V074__enforcement_warrant_of_restitution_details.sql b/src/main/resources/db/migration/V074__enforcement_warrant_of_restitution_details.sql new file mode 100644 index 0000000000..c5a3e29b5e --- /dev/null +++ b/src/main/resources/db/migration/V074__enforcement_warrant_of_restitution_details.sql @@ -0,0 +1,20 @@ +ALTER TABLE public.document +ADD COLUMN enf_case_id uuid REFERENCES enf_case(id); +CREATE INDEX idx_document_enf_case_id ON document(enf_case_id); + +-- Statement of Truth +ALTER TABLE enf_case +ADD COLUMN sot_id uuid REFERENCES statement_of_truth(id); + +ALTER TABLE public.enf_warrant_of_restitution + +-- How the defendants returned to the property +ADD COLUMN how_defendants_returned VARCHAR(6800), + +-- PropertyAccessDetails +ADD COLUMN is_difficult_to_access_property YES_NO, +ADD COLUMN clarification_on_access_difficulty_text VARCHAR(6800), + +-- Additional Information +ADD COLUMN additional_information_select YES_NO, +ADD COLUMN additional_information_details VARCHAR(6800); \ No newline at end of file diff --git a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/WarrantOfRestitutionPageConfigurerTest.java b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/WarrantOfRestitutionPageConfigurerTest.java index 35fd408dfc..ba4e38b806 100644 --- a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/WarrantOfRestitutionPageConfigurerTest.java +++ b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/page/enforcetheorder/warrantofrestitution/WarrantOfRestitutionPageConfigurerTest.java @@ -50,7 +50,7 @@ void shouldConfigurePagesInCorrectOrder() { InOrder inOrder = Mockito.inOrder(pageBuilder); Mockito.verify(pageBuilder, Mockito.atLeastOnce()).add(pageCaptor.capture()); AtomicInteger verificationCount = new AtomicInteger(0); - verifyAndCount(inOrder, pageBuilder, PeopleWhoWillBeEvictedWarrantRestPlaceholder.class, + verifyAndCount(inOrder, pageBuilder, PeopleYouWantToEvictWarrantRestPlaceholder.class, verificationCount); verifyAndCount(inOrder, pageBuilder, ShareEvidenceWithJudgePage.class, verificationCount); verifyAndCount(inOrder, pageBuilder, explainHowDefendantsReturnedPage, verificationCount); diff --git a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/DocumentServiceTest.java b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/DocumentServiceTest.java index 88e3d3d149..c39befba39 100644 --- a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/DocumentServiceTest.java +++ b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/DocumentServiceTest.java @@ -18,10 +18,15 @@ import uk.gov.hmcts.reform.pcs.ccd.domain.PCSCase; import uk.gov.hmcts.reform.pcs.ccd.domain.RentArrearsSection; import uk.gov.hmcts.reform.pcs.ccd.domain.TenancyLicenceDetails; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.EvidenceDocumentType; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.EvidenceOfDefendants; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.WarrantOfRestitutionDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.wales.OccupationLicenceDetailsWales; import uk.gov.hmcts.reform.pcs.ccd.entity.DocumentEntity; import uk.gov.hmcts.reform.pcs.ccd.repository.DocumentRepository; +import java.util.ArrayList; import java.util.List; import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; @@ -260,4 +265,59 @@ void shouldReturnEmptyListIfNoDocuments() { assertThat(entities).isEmpty(); verify(documentRepository).saveAll(anyList()); } + + @ParameterizedTest + @EnumSource(EvidenceDocumentType.class) + void shouldMapAllEvidenceDocumentTypes(EvidenceDocumentType evidenceDocumentType) { + // Given + EvidenceOfDefendants evidenceDocument = EvidenceOfDefendants.builder() + .document(Document.builder() + .url("url-WITNESS_STATEMENT") + .filename("file-WITNESS_STATEMENT") + .binaryUrl("bin-WITNESS_STATEMENT") + .categoryId("cat-WITNESS_STATEMENT") + .build()) + .documentType(evidenceDocumentType) + .build(); + + List> evidenceDocuments = + List.of(ListValue.builder() + .id("1").value(evidenceDocument).build()); + + EnforcementOrder enforcementOrder = EnforcementOrder.builder() + .warrantOfRestitutionDetails(WarrantOfRestitutionDetails.builder() + .additionalDocuments(evidenceDocuments) + .build()) + .build(); + + // When + underTest.createAllDocuments(enforcementOrder); + + // Then + DocumentType expectedDocumentType = DocumentType.valueOf(evidenceDocumentType.name()); + + verify(documentRepository).saveAll(documentEntityListCaptor.capture()); + List capturedEntities = documentEntityListCaptor.getValue(); + + assertThat(capturedEntities) + .extracting(DocumentEntity::getType) + .containsExactly(expectedDocumentType); + } + + @Test + void shouldHandleEmptyEvidenceDocument() { + List> evidenceDocuments = + new ArrayList<>(); + EnforcementOrder enforcementOrder = EnforcementOrder.builder() + .warrantOfRestitutionDetails(WarrantOfRestitutionDetails.builder() + .additionalDocuments(evidenceDocuments) + .build()) + .build(); + + // When + underTest.createAllDocuments(enforcementOrder); + + // Then + verify(documentRepository).saveAll(List.of()); + } } diff --git a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/EnforcementDataUtil.java b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/EnforcementDataUtil.java index 20b430ece9..7014cf84c7 100644 --- a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/EnforcementDataUtil.java +++ b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/EnforcementDataUtil.java @@ -14,6 +14,8 @@ import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.WarrantDetails; 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.enforcetheorder.EnforcementOrderEntity; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.RiskProfileEntity; import uk.gov.hmcts.reform.pcs.ccd.type.DynamicMultiSelectStringList; import uk.gov.hmcts.reform.pcs.ccd.type.DynamicStringList; import uk.gov.hmcts.reform.pcs.ccd.type.DynamicStringListElement; @@ -24,6 +26,7 @@ import java.util.UUID; import static uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.SelectEnforcementType.WARRANT; +import static uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.VulnerableCategory.VULNERABLE_CHILDREN; public final class EnforcementDataUtil { @@ -136,4 +139,21 @@ public static DynamicStringList buildEnforcementTypes() { .listItems(listItems) .build(); } + + public static RiskProfileEntity createExpectedRiskProfileEntity(EnforcementOrderEntity enforcementOrderEntity) { + RiskProfileEntity entity = new RiskProfileEntity(); + entity.setEnforcementOrder(enforcementOrderEntity); + entity.setAnyRiskToBailiff(YesNoNotSure.YES); + entity.setViolentDetails("Violent behavior reported"); + entity.setFirearmsDetails("Firearms present"); + entity.setCriminalDetails("Criminal history"); + entity.setVerbalThreatsDetails("Verbal threats made"); + entity.setProtestGroupDetails("Member of protest group"); + entity.setPoliceSocialServicesDetails("Police involvement"); + entity.setAnimalsDetails("Aggressive dogs on premises"); + entity.setVulnerablePeoplePresent(YesNoNotSure.YES); + entity.setVulnerableCategory(VULNERABLE_CHILDREN); + entity.setVulnerableReasonText("Young children present"); + return entity; + } } diff --git a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/RiskProfileServiceTest.java b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/RiskProfileServiceTest.java new file mode 100644 index 0000000000..f7617b6b35 --- /dev/null +++ b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/RiskProfileServiceTest.java @@ -0,0 +1,45 @@ +package uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.RiskProfileEntity; +import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.RiskProfileRepository; +import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper.RiskDetailsMapper; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.EnforcementDataUtil.createExpectedRiskProfileEntity; + +@ExtendWith(MockitoExtension.class) +class RiskProfileServiceTest { + + @Mock + private RiskDetailsMapper riskProfileMapper; + @Mock + private RiskProfileRepository riskProfileRepository; + @InjectMocks + private RiskProfileService underTest; + + @Test + void shouldProcessRiskDetailsSuccessfully() { + // Given + EnforcementOrderEntity enforcementOrderEntity = mock(EnforcementOrderEntity.class); + + EnforcementOrder enforcementOrder = mock(EnforcementOrder.class); + RiskProfileEntity riskProfileEntity = createExpectedRiskProfileEntity(enforcementOrderEntity); + when(riskProfileMapper.toEntity(any(), any())).thenReturn(riskProfileEntity); + + // When + underTest.processRisk(enforcementOrder, enforcementOrderEntity); + + // Then + verify(riskProfileRepository).save(riskProfileEntity); + } +} \ No newline at end of file diff --git a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/RiskDetailsMapperTest.java b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/RiskDetailsMapperTest.java index 49f9302db7..747d8e2478 100644 --- a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/RiskDetailsMapperTest.java +++ b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/RiskDetailsMapperTest.java @@ -8,17 +8,21 @@ import org.mockito.junit.jupiter.MockitoExtension; import uk.gov.hmcts.reform.pcs.ccd.domain.YesNoNotSure; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.SelectEnforcementType; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.RiskDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.RawWarrantDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.VulnerableAdultsChildren; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.VulnerableCategory; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.WarrantDetails; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.RawWarrantRestDetails; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.WarrantOfRestitutionDetails; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.RiskProfileEntity; import java.util.UUID; import static org.assertj.core.api.Assertions.assertThat; +import static uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.EnforcementDataUtil.buildEnforcementTypes; @ExtendWith(MockitoExtension.class) class RiskDetailsMapperTest { @@ -27,8 +31,8 @@ class RiskDetailsMapperTest { new RiskDetailsMapper(new ModelMapper()); @Nested - @DisplayName("toEntity") - class ToEntity { + @DisplayName("warrant") + class Warrant { @Test @DisplayName("maps full warrant and risk details to entity") @@ -36,6 +40,7 @@ void mapsFullWarrantAndRiskDetails() { EnforcementOrderEntity orderEntity = new EnforcementOrderEntity(); orderEntity.setId(UUID.randomUUID()); EnforcementOrder order = EnforcementOrder.builder() + .chooseEnforcementType(buildEnforcementTypes(SelectEnforcementType.WARRANT)) .warrantDetails(WarrantDetails.builder() .anyRiskToBailiff(YesNoNotSure.YES) .riskDetails(RiskDetails.builder() @@ -61,6 +66,7 @@ void mapsVulnerabilityDetails() { EnforcementOrderEntity orderEntity = new EnforcementOrderEntity(); orderEntity.setId(UUID.randomUUID()); EnforcementOrder order = EnforcementOrder.builder() + .chooseEnforcementType(buildEnforcementTypes(SelectEnforcementType.WARRANT)) .warrantDetails(WarrantDetails.builder().build()) .rawWarrantDetails(RawWarrantDetails.builder() .vulnerablePeoplePresent(YesNoNotSure.YES) @@ -84,9 +90,86 @@ void mapsWarrantDetailsWhenRiskDetailsNull() { EnforcementOrderEntity orderEntity = new EnforcementOrderEntity(); orderEntity.setId(UUID.randomUUID()); EnforcementOrder order = EnforcementOrder.builder() + .chooseEnforcementType(buildEnforcementTypes(SelectEnforcementType.WARRANT)) .warrantDetails(WarrantDetails.builder() .anyRiskToBailiff(YesNoNotSure.NO) .build()) + .rawWarrantDetails(RawWarrantDetails.builder() + .build()) + .build(); + + RiskProfileEntity result = mapper.toEntity(orderEntity, order); + assertThat(result.getAnyRiskToBailiff()).isEqualTo(YesNoNotSure.NO); + assertThat(result.getViolentDetails()).isNull(); + assertThat(result.getVerbalThreatsDetails()).isNull(); + } + } + + @Nested + @DisplayName("warrantOfRestitution") + class WarrantOfRestitution { + @Test + @DisplayName("maps full warrant of restitution and risk details to entity") + void mapsFullWarrantOfRestitutionAndRiskDetails() { + EnforcementOrderEntity orderEntity = new EnforcementOrderEntity(); + orderEntity.setId(UUID.randomUUID()); + EnforcementOrder order = EnforcementOrder.builder() + .chooseEnforcementType(buildEnforcementTypes(SelectEnforcementType.WARRANT_OF_RESTITUTION)) + .warrantOfRestitutionDetails(WarrantOfRestitutionDetails.builder() + .anyRiskToBailiff(YesNoNotSure.YES) + .riskDetails(RiskDetails.builder() + .violentDetails("Violent") + .verbalThreatsDetails("Verbal") + .firearmsDetails("Firearms") + .build()) + .build()) + .build(); + + RiskProfileEntity result = mapper.toEntity(orderEntity, order); + + assertThat(result.getEnforcementOrder()).isEqualTo(orderEntity); + assertThat(result.getAnyRiskToBailiff()).isEqualTo(YesNoNotSure.YES); + assertThat(result.getViolentDetails()).isEqualTo("Violent"); + assertThat(result.getVerbalThreatsDetails()).isEqualTo("Verbal"); + assertThat(result.getFirearmsDetails()).isEqualTo("Firearms"); + } + + @Test + @DisplayName("maps vulnerability details from raw warrant details") + void mapsVulnerabilityDetails() { + EnforcementOrderEntity orderEntity = new EnforcementOrderEntity(); + orderEntity.setId(UUID.randomUUID()); + EnforcementOrder order = EnforcementOrder.builder() + .chooseEnforcementType(buildEnforcementTypes(SelectEnforcementType.WARRANT_OF_RESTITUTION)) + .warrantOfRestitutionDetails(WarrantOfRestitutionDetails.builder().build()) + .rawWarrantRestDetails(RawWarrantRestDetails.builder() + .vulnerablePeoplePresentWarrantRest(YesNoNotSure.YES) + .vulnerableAdultsChildrenWarrantRest(VulnerableAdultsChildren.builder() + .vulnerableCategory(VulnerableCategory.VULNERABLE_ADULTS) + .vulnerableReasonText("Vulnerability reason") + .build()) + .build()) + .build(); + + RiskProfileEntity result = mapper.toEntity(orderEntity, order); + + assertThat(result.getVulnerablePeoplePresent()).isEqualTo(YesNoNotSure.YES); + assertThat(result.getVulnerableCategory()).isEqualTo(VulnerableCategory.VULNERABLE_ADULTS); + assertThat(result.getVulnerableReasonText()).isEqualTo("Vulnerability reason"); + } + + @Test + @DisplayName("maps warrant of restitution details when risk details is null") + void mapsWarrantOfRestitutionDetailsWhenRiskDetailsNull() { + EnforcementOrderEntity orderEntity = new EnforcementOrderEntity(); + orderEntity.setId(UUID.randomUUID()); + EnforcementOrder order = EnforcementOrder.builder() + .chooseEnforcementType(buildEnforcementTypes(SelectEnforcementType.WARRANT_OF_RESTITUTION)) + .warrantOfRestitutionDetails(WarrantOfRestitutionDetails.builder() + .anyRiskToBailiff(YesNoNotSure.NO) + .build()) + .rawWarrantRestDetails(RawWarrantRestDetails.builder() + .build()) .build(); RiskProfileEntity result = mapper.toEntity(orderEntity, order); diff --git a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/WarrantOfRestitutionMapperTest.java b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/WarrantOfRestitutionMapperTest.java index d7c42dfaaa..3a6971c372 100644 --- a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/WarrantOfRestitutionMapperTest.java +++ b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/mapper/WarrantOfRestitutionMapperTest.java @@ -1,19 +1,27 @@ package uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; +import uk.gov.hmcts.ccd.sdk.type.YesOrNo; import uk.gov.hmcts.reform.pcs.ccd.domain.VerticalYesNo; import uk.gov.hmcts.reform.pcs.ccd.domain.YesNoNotSure; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.LegalCosts; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.RiskDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.PropertyAccessDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.RiskCategory; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.VulnerableAdultsChildren; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.VulnerableCategory; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.AdditionalInformation; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.RawWarrantDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.WarrantDetails; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.WarrantOfRestitutionDetails; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; +import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.WarrantOfRestitutionEntity; +import java.math.BigDecimal; import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; @@ -21,7 +29,13 @@ @ExtendWith(MockitoExtension.class) class WarrantOfRestitutionMapperTest { - private final WarrantOfRestitutionMapper mapper = new WarrantOfRestitutionMapper(); + private final WarrantOfRestitutionMapper underTest = new WarrantOfRestitutionMapper(); + private EnforcementOrderEntity enforcementOrderEntity; + + @BeforeEach + void setUp() { + enforcementOrderEntity = new EnforcementOrderEntity(); + } @Test void shouldMapWarrantFieldsToWarrantOfRest() { @@ -33,6 +47,10 @@ void shouldMapWarrantFieldsToWarrantOfRest() { .isDifficultToAccessProperty(VerticalYesNo.YES) .clarificationOnAccessDifficultyText("original") .build()) + .additionalInformation(AdditionalInformation.builder() + .additionalInformationDetails("additional details") + .additionalInformationSelect(VerticalYesNo.YES) + .build()) .riskCategories(Set.of(RiskCategory.VIOLENT_OR_AGGRESSIVE)) .riskDetails(RiskDetails.builder() .violentDetails("violent") @@ -54,7 +72,7 @@ void shouldMapWarrantFieldsToWarrantOfRest() { EnforcementOrder target = EnforcementOrder.builder().build(); // When - mapper.prePopulateFieldsFromWarrantDetails(source, target); + underTest.prePopulateFieldsFromWarrantDetails(source, target); // Then - values copied assertThat(target.getWarrantOfRestitutionDetails()).isNotNull(); @@ -97,7 +115,7 @@ void shouldHandleNullFields() { EnforcementOrder target = EnforcementOrder.builder().build(); // When - mapper.prePopulateFieldsFromWarrantDetails(source, target); + underTest.prePopulateFieldsFromWarrantDetails(source, target); // Then assertThat(target.getWarrantOfRestitutionDetails().getRiskCategories()).isNull(); @@ -106,4 +124,123 @@ void shouldHandleNullFields() { assertThat(target.getRawWarrantRestDetails().getVulnerableAdultsChildrenWarrantRest()).isNull(); assertThat(target.getRawWarrantRestDetails().getVulnerablePeoplePresentWarrantRest()).isNull(); } + + @Test + void shouldMapToEntityWithNullWarrantOfRestitutionDetails() { + // Given + EnforcementOrder enforcementOrder = EnforcementOrder.builder().build(); + + // When + WarrantOfRestitutionEntity result = underTest.toEntity(enforcementOrder, enforcementOrderEntity); + + // Then + assertThat(result).isNotNull(); + assertThat(result.getEnforcementOrder()).isEqualTo(enforcementOrderEntity); + } + + @Test + void shouldMapMapAdditionalInformation() { + // Given + AdditionalInformation additionalInfo = AdditionalInformation.builder() + .additionalInformationSelect(VerticalYesNo.YES) + .additionalInformationDetails("Additional details") + .build(); + + WarrantOfRestitutionDetails warrantOfRestitutionDetails = WarrantOfRestitutionDetails.builder() + .additionalInformation(additionalInfo).build(); + EnforcementOrder enforcementOrder = EnforcementOrder.builder() + .warrantOfRestitutionDetails(warrantOfRestitutionDetails).build(); + + // When + WarrantOfRestitutionEntity result = underTest.toEntity(enforcementOrder, enforcementOrderEntity); + + // Then + assertThat(result.getAdditionalInformationSelect()).isEqualTo(VerticalYesNo.YES); + assertThat(result.getAdditionalInformationDetails()).isEqualTo("Additional details"); + } + + @Test + void shouldHandleNullMapAdditionalInformation() { + // Given + WarrantOfRestitutionDetails warrantOfRestitutionDetails = WarrantOfRestitutionDetails.builder() + .additionalInformation(null) + .build(); + + EnforcementOrder enforcementOrder = EnforcementOrder.builder() + .warrantOfRestitutionDetails(warrantOfRestitutionDetails) + .build(); + + // When + WarrantOfRestitutionEntity result = underTest.toEntity(enforcementOrder, enforcementOrderEntity); + + // Then + assertThat(result.getAdditionalInformationSelect()).isNull(); + assertThat(result.getAdditionalInformationDetails()).isNull(); + } + + @Test + void shouldMapDefendantReturned() { + // Given + WarrantOfRestitutionDetails warrantOfRestitutionDetails = WarrantOfRestitutionDetails.builder() + .howDefendantsReturned("defendants returned test").build(); + EnforcementOrder enforcementOrder = EnforcementOrder.builder() + .warrantOfRestitutionDetails(warrantOfRestitutionDetails).build(); + + // When + WarrantOfRestitutionEntity result = underTest.toEntity(enforcementOrder, enforcementOrderEntity); + + // Then + assertThat(result.getHowDefendantsReturned()).isEqualTo("defendants returned test"); + } + + @Test + void shouldMapMapPropertyAccessDetails() { + // Given + PropertyAccessDetails accessDetails = PropertyAccessDetails.builder() + .isDifficultToAccessProperty(VerticalYesNo.YES) + .clarificationOnAccessDifficultyText("Hard to access") + .build(); + + WarrantOfRestitutionDetails warrantOfRestitutionDetails = WarrantOfRestitutionDetails.builder() + .propertyAccessDetails(accessDetails).build(); + EnforcementOrder enforcementOrder = EnforcementOrder.builder() + .warrantOfRestitutionDetails(warrantOfRestitutionDetails).build(); + + // When + WarrantOfRestitutionEntity result = underTest.toEntity(enforcementOrder, enforcementOrderEntity); + + // Then + assertThat(result.getIsDifficultToAccessProperty()).isEqualTo(VerticalYesNo.YES); + assertThat(result.getClarificationOnAccessDifficultyText()).isEqualTo("Hard to access"); + } + + @Test + void shouldMapCompleteWarrantDetails() { + // Given + EnforcementOrder enforcementOrder = createCompleteEnforcementOrder(); + + // When + WarrantOfRestitutionEntity result = underTest.toEntity(enforcementOrder, enforcementOrderEntity); + + // Then + assertThat(result).isNotNull(); + assertThat(result.getEnforcementOrder()).isEqualTo(enforcementOrderEntity); + } + + private EnforcementOrder createCompleteEnforcementOrder() { + WarrantDetails warrantDetails = WarrantDetails.builder() + .showChangeNameAddressPage(YesOrNo.YES) + .isSuspendedOrder(VerticalYesNo.NO) + .additionalInformation(AdditionalInformation.builder() + .additionalInformationSelect(VerticalYesNo.YES) + .additionalInformationDetails("Details") + .build()) + .legalCosts(LegalCosts.builder() + .areLegalCostsToBeClaimed(VerticalYesNo.YES) + .amountOfLegalCosts(new BigDecimal("1000.00")) + .build()) + .build(); + + return EnforcementOrder.builder().warrantDetails(warrantDetails).build(); + } } \ No newline at end of file diff --git a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantOfRestitutionStrategyTest.java b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantOfRestitutionStrategyTest.java index f17e309b4b..1fe823dad4 100644 --- a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantOfRestitutionStrategyTest.java +++ b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantOfRestitutionStrategyTest.java @@ -6,38 +6,122 @@ import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; +import uk.gov.hmcts.ccd.sdk.type.Document; +import uk.gov.hmcts.ccd.sdk.type.ListValue; +import uk.gov.hmcts.reform.pcs.ccd.domain.YesNoNotSure; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.VulnerableAdultsChildren; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.EvidenceDocumentType; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.EvidenceOfDefendants; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.RawWarrantRestDetails; +import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrantofrestitution.WarrantOfRestitutionDetails; +import uk.gov.hmcts.reform.pcs.ccd.entity.DocumentEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.WarrantOfRestitutionEntity; +import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.EnforcementOrderRepository; import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.WarrantOfRestitutionRepository; +import uk.gov.hmcts.reform.pcs.ccd.service.DocumentService; +import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.RiskProfileService; +import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper.WarrantOfRestitutionMapper; + +import java.util.List; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.VulnerableCategory.VULNERABLE_CHILDREN; @ExtendWith(MockitoExtension.class) -public class WarrantOfRestitutionStrategyTest { +class WarrantOfRestitutionStrategyTest { @InjectMocks private WarrantOfRestitutionStrategy underTest; @Mock + private RiskProfileService riskProfileService; + @Mock + private WarrantOfRestitutionMapper warrantOfRestitutionMapper; + @Mock private WarrantOfRestitutionRepository warrantOfRestitutionRepository; + @Mock + private EnforcementOrderRepository enforcementOrderRepository; + @Mock + private DocumentService documentService; @Test - void shouldProcess() { + void shouldProcessWarrantOfRestitutionDetailsAndSaveToRepository() { // Given - EnforcementOrderEntity enforcementOrderEntity = new EnforcementOrderEntity(); - EnforcementOrder enforcementOrder = new EnforcementOrder(); + WarrantOfRestitutionDetails warrantOfRestitutionDetails; + EnforcementOrderEntity enforcementOrderEntity = mock(EnforcementOrderEntity.class); + warrantOfRestitutionDetails = WarrantOfRestitutionDetails.builder().anyRiskToBailiff(YesNoNotSure.YES).build(); + + VulnerableAdultsChildren vulnerableAdultsChildren = VulnerableAdultsChildren.builder() + .vulnerableCategory(VULNERABLE_CHILDREN).vulnerableReasonText("Young children present").build(); + + RawWarrantRestDetails rawWarrantRestDetails = RawWarrantRestDetails.builder() + .vulnerablePeoplePresentWarrantRest(YesNoNotSure.YES) + .vulnerableAdultsChildrenWarrantRest(vulnerableAdultsChildren).build(); + + EnforcementOrder enforcementOrder = EnforcementOrder.builder() + .warrantOfRestitutionDetails(warrantOfRestitutionDetails) + .rawWarrantRestDetails(rawWarrantRestDetails).build(); + WarrantOfRestitutionEntity warrantOfRestitutionEntity = WarrantOfRestitutionEntity.builder() + .enforcementOrder(enforcementOrderEntity) + .build(); + when(warrantOfRestitutionMapper.toEntity(enforcementOrder, enforcementOrderEntity)) + .thenReturn(warrantOfRestitutionEntity); + when(warrantOfRestitutionRepository.save(warrantOfRestitutionEntity)).thenReturn(warrantOfRestitutionEntity); // When underTest.process(enforcementOrderEntity, enforcementOrder); ArgumentCaptor captor = ArgumentCaptor.forClass(WarrantOfRestitutionEntity.class); // Then + verify(riskProfileService).processRisk(enforcementOrder, enforcementOrderEntity); verify(warrantOfRestitutionRepository).save(captor.capture()); WarrantOfRestitutionEntity saved = captor.getValue(); assertThat(saved).isNotNull(); assertThat(saved.getEnforcementOrder()).isSameAs(enforcementOrderEntity); } + @Test + void shouldProcessDocumentsAndSaveToRepository() { + // Given + EvidenceOfDefendants evidenceDocument = EvidenceOfDefendants.builder() + .document(Document.builder() + .url("url-WITNESS_STATEMENT") + .filename("file-WITNESS_STATEMENT") + .binaryUrl("bin-WITNESS_STATEMENT") + .categoryId("cat-WITNESS_STATEMENT") + .build()) + .documentType(EvidenceDocumentType.WITNESS_STATEMENT) + .build(); + + List> evidenceDocuments = + List.of(ListValue.builder() + .id("1").value(evidenceDocument).build()); + + EnforcementOrder enforcementOrder = EnforcementOrder.builder() + .warrantOfRestitutionDetails(WarrantOfRestitutionDetails.builder() + .additionalDocuments(evidenceDocuments) + .build()) + .build(); + EnforcementOrderEntity enforcementOrderEntity = EnforcementOrderEntity.builder().build(); + + WarrantOfRestitutionEntity warrantOfRestitutionEntity = WarrantOfRestitutionEntity.builder().build(); + List documentEntities = List.of(DocumentEntity.builder().build()); + enforcementOrderEntity.addDocuments(documentEntities); + + when(warrantOfRestitutionMapper.toEntity(enforcementOrder, enforcementOrderEntity)) + .thenReturn(warrantOfRestitutionEntity); + when(warrantOfRestitutionRepository.save(warrantOfRestitutionEntity)).thenReturn(warrantOfRestitutionEntity); + when(documentService.createAllDocuments(enforcementOrder)).thenReturn(documentEntities); + + // When + underTest.process(enforcementOrderEntity, enforcementOrder); + + // Then + verify(enforcementOrderRepository).save(enforcementOrderEntity); + } } diff --git a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantStrategyTest.java b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantStrategyTest.java index 6252e72d28..52d5939c44 100644 --- a/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantStrategyTest.java +++ b/src/test/java/uk/gov/hmcts/reform/pcs/ccd/service/enforcetheorder/strategy/WarrantStrategyTest.java @@ -15,23 +15,19 @@ import uk.gov.hmcts.reform.pcs.ccd.domain.VerticalYesNo; import uk.gov.hmcts.reform.pcs.ccd.domain.YesNoNotSure; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.EnforcementOrder; -import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.RiskDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.NameAndAddressForEviction; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.PeopleToEvict; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.RawWarrantDetails; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.VulnerableAdultsChildren; -import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.common.VulnerableCategory; import uk.gov.hmcts.reform.pcs.ccd.domain.enforcetheorder.warrant.WarrantDetails; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.EnforcementOrderEntity; -import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.RiskProfileEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.SelectedDefendantEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.enforcetheorder.WarrantEntity; import uk.gov.hmcts.reform.pcs.ccd.entity.party.PartyEntity; -import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.RiskProfileRepository; import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.SelectedDefendantRepository; import uk.gov.hmcts.reform.pcs.ccd.repository.enforcetheorder.WarrantRepository; import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.EnforcementDataUtil; -import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper.RiskDetailsMapper; +import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.RiskProfileService; import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper.SelectedDefendantsMapper; import uk.gov.hmcts.reform.pcs.ccd.service.enforcetheorder.mapper.WarrantDetailsMapper; import uk.gov.hmcts.reform.pcs.ccd.type.DynamicStringListElement; @@ -44,7 +40,6 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.argThat; -import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; @@ -59,20 +54,17 @@ class WarrantStrategyTest { @Mock - private RiskProfileRepository riskProfileRepository; + private RiskProfileService riskProfileService; @Mock private SelectedDefendantsMapper selectedDefendantsMapper; @Mock private SelectedDefendantRepository selectedDefendantRepository; - @Mock - private RiskDetailsMapper riskProfileMapper; + @Mock private WarrantDetailsMapper warrantDetailsMapper; @Mock private WarrantRepository warrantRepository; @Captor - private ArgumentCaptor riskProfileCaptor; - @Captor private ArgumentCaptor warrantEntityCaptor; @Captor private ArgumentCaptor> selectedDefendantEntityCaptor; @@ -82,24 +74,12 @@ class WarrantStrategyTest { private EnforcementOrderEntity enforcementOrderEntity; private EnforcementOrder enforcementOrder; - private WarrantDetails warrantDetails; - private RiskDetails riskDetails; @BeforeEach void setUp() { enforcementOrderEntity = mock(EnforcementOrderEntity.class); - riskDetails = RiskDetails.builder() - .violentDetails("Violent behavior reported") - .firearmsDetails("Firearms present") - .criminalDetails("Criminal history") - .verbalThreatsDetails("Verbal threats made") - .protestGroupDetails("Member of protest group") - .policeSocialServicesDetails("Police involvement") - .animalsDetails("Aggressive dogs on premises") - .build(); - - warrantDetails = WarrantDetails.builder().anyRiskToBailiff(YesNoNotSure.YES).riskDetails(riskDetails).build(); + WarrantDetails warrantDetails = WarrantDetails.builder().anyRiskToBailiff(YesNoNotSure.YES).build(); VulnerableAdultsChildren vulnerableAdultsChildren = VulnerableAdultsChildren.builder() .vulnerableCategory(VULNERABLE_CHILDREN).vulnerableReasonText("Young children present").build(); @@ -121,11 +101,8 @@ void shouldProcessWarrantDetailsAndSaveToRepository() { when(warrantDetailsMapper.toEntity(enforcementOrder, enforcementOrderEntity)) .thenReturn(warrantEntity); when(warrantRepository.save(warrantEntity)).thenReturn(savedWarrantEntity); - when(riskProfileMapper.toEntity(any(), any())).thenReturn(new RiskProfileEntity()); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(new RiskProfileEntity()); when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)) .thenReturn(Collections.emptyList()); - // When underTest.process(enforcementOrderEntity, enforcementOrder); @@ -133,6 +110,7 @@ void shouldProcessWarrantDetailsAndSaveToRepository() { verify(warrantDetailsMapper).toEntity(enforcementOrder, enforcementOrderEntity); verify(warrantRepository).save(warrantEntity); verify(enforcementOrderEntity).setWarrantDetails(savedWarrantEntity); + verify(riskProfileService).processRisk(enforcementOrder, enforcementOrderEntity); } @Test @@ -146,8 +124,6 @@ void shouldSetSavedWarrantDetailsOnEnforcementOrderEntity() { when(warrantDetailsMapper.toEntity(enforcementOrder, enforcementOrderEntity)) .thenReturn(warrantEntity); when(warrantRepository.save(warrantEntity)).thenReturn(savedWarrantEntity); - when(riskProfileMapper.toEntity(any(), any())).thenReturn(new RiskProfileEntity()); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(new RiskProfileEntity()); when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)) .thenReturn(Collections.emptyList()); @@ -161,29 +137,6 @@ void shouldSetSavedWarrantDetailsOnEnforcementOrderEntity() { verify(enforcementOrderEntity).setWarrantDetails(savedWarrantEntity); } - @Test - void shouldProcessWarrantBeforeRiskProfile() { - // Given - WarrantEntity warrantEntity = new WarrantEntity(); - WarrantEntity savedWarrantEntity = new WarrantEntity(); - - when(warrantDetailsMapper.toEntity(enforcementOrder, enforcementOrderEntity)) - .thenReturn(warrantEntity); - when(warrantRepository.save(warrantEntity)).thenReturn(savedWarrantEntity); - when(riskProfileMapper.toEntity(any(), any())).thenReturn(new RiskProfileEntity()); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(new RiskProfileEntity()); - when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)) - .thenReturn(Collections.emptyList()); - - // When - underTest.process(enforcementOrderEntity, enforcementOrder); - - // Then - InOrder inOrder = inOrder(warrantRepository, riskProfileRepository); - inOrder.verify(warrantRepository).save(warrantEntity); - inOrder.verify(riskProfileRepository).save(any(RiskProfileEntity.class)); - } - @Test void shouldCallWarrantDetailsMapper() { // Given @@ -193,8 +146,6 @@ void shouldCallWarrantDetailsMapper() { when(warrantDetailsMapper.toEntity(enforcementOrder, enforcementOrderEntity)) .thenReturn(warrantEntity); when(warrantRepository.save(warrantEntity)).thenReturn(savedWarrantEntity); - when(riskProfileMapper.toEntity(any(), any())).thenReturn(new RiskProfileEntity()); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(new RiskProfileEntity()); when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)) .thenReturn(Collections.emptyList()); @@ -218,8 +169,6 @@ void shouldProcessAllThreeStepsInCorrectOrder() { when(warrantDetailsMapper.toEntity(enforcementOrder, enforcementOrderEntity)) .thenReturn(warrantEntity); when(warrantRepository.save(warrantEntity)).thenReturn(savedWarrantEntity); - when(riskProfileMapper.toEntity(any(), any())).thenReturn(new RiskProfileEntity()); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(new RiskProfileEntity()); when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)).thenReturn(defendants); // When @@ -228,95 +177,17 @@ void shouldProcessAllThreeStepsInCorrectOrder() { // Then InOrder inOrder = inOrder( warrantRepository, - riskProfileRepository, selectedDefendantRepository ); inOrder.verify(warrantRepository).save(warrantEntity); - inOrder.verify(riskProfileRepository).save(any(RiskProfileEntity.class)); inOrder.verify(selectedDefendantRepository).saveAll(defendants); } - @Test - void shouldProcessWarrantDetailsSuccessfully() { - // Given - RiskProfileEntity savedEntity = createExpectedRiskProfileEntity(); - when(riskProfileMapper.toEntity(any(), any())).thenReturn(savedEntity); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(savedEntity); - when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)) - .thenReturn(Collections.emptyList()); - - // When - underTest.process(enforcementOrderEntity, enforcementOrder); - - // Then - verify(riskProfileRepository).save(riskProfileCaptor.capture()); - RiskProfileEntity capturedEntity = riskProfileCaptor.getValue(); - - assertThat(capturedEntity.getEnforcementOrder()).isEqualTo(enforcementOrderEntity); - assertThat(capturedEntity.getAnyRiskToBailiff()).isEqualTo(YesNoNotSure.YES); - assertThat(capturedEntity.getViolentDetails()).isEqualTo("Violent behavior reported"); - assertThat(capturedEntity.getFirearmsDetails()).isEqualTo("Firearms present"); - assertThat(capturedEntity.getCriminalDetails()).isEqualTo("Criminal history"); - assertThat(capturedEntity.getVerbalThreatsDetails()).isEqualTo("Verbal threats made"); - assertThat(capturedEntity.getProtestGroupDetails()).isEqualTo("Member of protest group"); - assertThat(capturedEntity.getPoliceSocialServicesDetails()).isEqualTo("Police involvement"); - assertThat(capturedEntity.getAnimalsDetails()).isEqualTo("Aggressive dogs on premises"); - assertThat(capturedEntity.getVulnerablePeoplePresent()).isEqualTo(YesNoNotSure.YES); - assertThat(capturedEntity.getVulnerableCategory()).isEqualTo(VULNERABLE_CHILDREN); - assertThat(capturedEntity.getVulnerableReasonText()).isEqualTo("Young children present"); - } - - @ParameterizedTest - @MethodSource("provideNullWarrantDetailsScenarios") - void shouldHandleNullValuesInWarrantDetails( - RawWarrantDetails rawWarrantDetails, - YesNoNotSure expectedVulnerablePeoplePresent, - boolean expectNullVulnerableFields - ) { - // Given - enforcementOrder.setRawWarrantDetails(rawWarrantDetails); - RiskProfileEntity riskProfileEntity = new RiskProfileEntity(); - if (expectedVulnerablePeoplePresent != null) { - riskProfileEntity.setVulnerablePeoplePresent(expectedVulnerablePeoplePresent); - } - when(riskProfileMapper.toEntity(any(), any())).thenReturn(riskProfileEntity); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(new RiskProfileEntity()); - when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)) - .thenReturn(Collections.emptyList()); - - // When - underTest.process(enforcementOrderEntity, enforcementOrder); - - // Then - verify(riskProfileRepository).save(riskProfileCaptor.capture()); - RiskProfileEntity capturedEntity = riskProfileCaptor.getValue(); - - assertThat(capturedEntity.getVulnerablePeoplePresent()).isEqualTo(expectedVulnerablePeoplePresent); - if (expectNullVulnerableFields) { - assertThat(capturedEntity.getVulnerableCategory()).isNull(); - assertThat(capturedEntity.getVulnerableReasonText()).isNull(); - } - } - - private static Stream provideNullWarrantDetailsScenarios() { - RawWarrantDetails withNullVulnerableChildren = RawWarrantDetails.builder() - .vulnerablePeoplePresent(YesNoNotSure.YES) - .vulnerableAdultsChildren(null) - .build(); - - return Stream.of( - Arguments.of(null, null, true), - Arguments.of(withNullVulnerableChildren, YesNoNotSure.YES, true) - ); - } - @ParameterizedTest @MethodSource("provideSelectedDefendantScenarios") void shouldHandleSelectedDefendantsBasedOnMapperResult(List defendants, boolean shouldCallSaveAll) { // Given - when(riskProfileMapper.toEntity(any(), any())).thenReturn(new RiskProfileEntity()); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(new RiskProfileEntity()); when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)).thenReturn(defendants); // When @@ -341,111 +212,6 @@ private static Stream provideSelectedDefendantScenarios() { ); } - - @Test - void shouldHandleWarrantDetailsWithNoRiskToBailiff() { - // Given - warrantDetails.setAnyRiskToBailiff(YesNoNotSure.NO); - RiskProfileEntity riskProfileEntity = new RiskProfileEntity(); - riskProfileEntity.setAnyRiskToBailiff(YesNoNotSure.NO); - when(riskProfileMapper.toEntity(any(), any())).thenReturn(riskProfileEntity); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(new RiskProfileEntity()); - when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)) - .thenReturn(Collections.emptyList()); - - // When - underTest.process(enforcementOrderEntity, enforcementOrder); - - // Then - verify(riskProfileRepository).save(riskProfileCaptor.capture()); - RiskProfileEntity capturedEntity = riskProfileCaptor.getValue(); - - assertThat(capturedEntity.getAnyRiskToBailiff()).isEqualTo(YesNoNotSure.NO); - } - - @Test - void shouldHandleMinimalEnforcementOrder() { - // Given - RiskProfileEntity riskProfileEntity = createExpectedRiskProfileEntity(); - riskProfileEntity.setAnyRiskToBailiff(null); - when(riskProfileMapper.toEntity(any(), any())).thenReturn(riskProfileEntity); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(riskProfileEntity); - when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)).thenReturn(Collections.emptyList()); - EnforcementOrder minimalOrder = EnforcementOrder.builder().build(); - - // When - underTest.process(enforcementOrderEntity, minimalOrder); - - // Then - verify(riskProfileRepository).save(riskProfileCaptor.capture()); - RiskProfileEntity capturedEntity = riskProfileCaptor.getValue(); - - assertThat(capturedEntity.getEnforcementOrder()).isEqualTo(enforcementOrderEntity); - assertThat(capturedEntity.getAnyRiskToBailiff()).isNull(); - } - - @Test - void shouldMapAllRiskDetailsFieldsCorrectly() { - // Given - RiskProfileEntity riskProfileEntity = createExpectedRiskProfileEntity(); - when(riskProfileMapper.toEntity(any(), any())).thenReturn(riskProfileEntity); - when(riskProfileRepository.save(riskProfileEntity)).thenReturn(riskProfileEntity); - when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)) - .thenReturn(Collections.emptyList()); - - // When - underTest.process(enforcementOrderEntity, enforcementOrder); - - // Then - verify(riskProfileRepository).save(riskProfileCaptor.capture()); - RiskProfileEntity capturedEntity = riskProfileCaptor.getValue(); - - assertThat(capturedEntity.getViolentDetails()).isEqualTo(riskDetails.getViolentDetails()); - assertThat(capturedEntity.getFirearmsDetails()).isEqualTo(riskDetails.getFirearmsDetails()); - assertThat(capturedEntity.getCriminalDetails()).isEqualTo(riskDetails.getCriminalDetails()); - assertThat(capturedEntity.getVerbalThreatsDetails()).isEqualTo(riskDetails.getVerbalThreatsDetails()); - assertThat(capturedEntity.getProtestGroupDetails()).isEqualTo(riskDetails.getProtestGroupDetails()); - assertThat(capturedEntity.getPoliceSocialServicesDetails()) - .isEqualTo(riskDetails.getPoliceSocialServicesDetails()); - assertThat(capturedEntity.getAnimalsDetails()).isEqualTo(riskDetails.getAnimalsDetails()); - } - - @Test - void shouldSaveRiskProfileBeforeSelectedDefendants() { - // Given - List defendants = List.of(new SelectedDefendantEntity()); - when(riskProfileMapper.toEntity(any(), any())).thenReturn(new RiskProfileEntity()); - when(riskProfileRepository.save(any(RiskProfileEntity.class))).thenReturn(new RiskProfileEntity()); - when(selectedDefendantsMapper.mapToEntities(enforcementOrderEntity)).thenReturn(defendants); - - // When - underTest.process(enforcementOrderEntity, enforcementOrder); - - // Then - InOrder inOrder = inOrder(riskProfileRepository, selectedDefendantRepository); - inOrder.verify(riskProfileRepository).save(any(RiskProfileEntity.class)); - inOrder.verify(selectedDefendantRepository).saveAll(defendants); - } - - @Test - void shouldPersistVulnerabilityDetailsInRiskProfile() { - // Given: order with raw warrant details (vulnerability) - final EnforcementOrder enfOrder = EnforcementDataUtil.buildEnforcementOrderWithVulnerability(); - final RiskProfileEntity stubbedRiskProfile = new RiskProfileEntity(); - stubbedRiskProfile.setVulnerablePeoplePresent(YesNoNotSure.YES); - stubbedRiskProfile.setVulnerableCategory(VulnerableCategory.VULNERABLE_ADULTS); - stubbedRiskProfile.setVulnerableReasonText("Vulnerability reason"); - when(riskProfileMapper.toEntity(any(EnforcementOrderEntity.class), eq(enfOrder))) - .thenReturn(stubbedRiskProfile); - - // When - underTest.process(enforcementOrderEntity, enfOrder); - - // Then: service calls mapper and saves returned risk profile - verify(riskProfileMapper).toEntity(any(), any()); - verify(riskProfileRepository).save(riskProfileCaptor.capture()); - } - @Test void shouldAddMultipleSelectedDefendantsWhenProvided() { // Given @@ -522,22 +288,4 @@ void shouldNotAddAnySelectedDefendantsWhenEvictEveryoneIsYes() { // Then verifyNoInteractions(selectedDefendantRepository); } - - private RiskProfileEntity createExpectedRiskProfileEntity() { - RiskProfileEntity entity = new RiskProfileEntity(); - entity.setEnforcementOrder(enforcementOrderEntity); - entity.setAnyRiskToBailiff(YesNoNotSure.YES); - entity.setViolentDetails("Violent behavior reported"); - entity.setFirearmsDetails("Firearms present"); - entity.setCriminalDetails("Criminal history"); - entity.setVerbalThreatsDetails("Verbal threats made"); - entity.setProtestGroupDetails("Member of protest group"); - entity.setPoliceSocialServicesDetails("Police involvement"); - entity.setAnimalsDetails("Aggressive dogs on premises"); - entity.setVulnerablePeoplePresent(YesNoNotSure.YES); - entity.setVulnerableCategory(VULNERABLE_CHILDREN); - entity.setVulnerableReasonText("Young children present"); - return entity; - } - }