diff --git a/build.gradle b/build.gradle index 3d15376874..4cf2f2dda7 100644 --- a/build.gradle +++ b/build.gradle @@ -21,7 +21,7 @@ plugins { id 'org.jetbrains.gradle.plugin.idea-ext' version '0.7' id 'info.solidsoft.pitest' version '1.15.0' id 'uk.gov.hmcts.java' version '0.12.57' - id 'au.com.dius.pact' version '4.3.12' + id 'au.com.dius.pact' version '4.6.14' id "org.jsonschema2pojo" version "1.2.1" } @@ -661,8 +661,8 @@ jsonSchema2Pojo { sonarqube { properties { property "sonar.exclusions", "build/generated-sources/**/*.java," + - "**/AppInsightsConfiguration.java," + - "**/TestingSupportController.java" + "**/AppInsightsConfiguration.java,**/domain/**/*,,**/data/**/*,**/ApplicationParams.java," + + "**/UserAuthHeadersInterceptor.java,**/TestingSupportController.java" property "sonar.projectName", "ccd-data-store-api" property "sonar.projectKey", "ccd-data-store-api" property "sonar.coverage.jacoco.xmlReportPaths", "${jacocoTestReport.reports.xml.outputLocation}" diff --git a/src/contractTest/java/uk/gov/hmcts/ccd/v2/external/controller/ContractTestSubmitCaseTransaction.java b/src/contractTest/java/uk/gov/hmcts/ccd/v2/external/controller/ContractTestSubmitCaseTransaction.java index d74e597156..419b2231b2 100644 --- a/src/contractTest/java/uk/gov/hmcts/ccd/v2/external/controller/ContractTestSubmitCaseTransaction.java +++ b/src/contractTest/java/uk/gov/hmcts/ccd/v2/external/controller/ContractTestSubmitCaseTransaction.java @@ -12,6 +12,7 @@ import uk.gov.hmcts.ccd.domain.service.common.CaseTypeService; import uk.gov.hmcts.ccd.domain.service.common.SecurityClassificationService; import uk.gov.hmcts.ccd.domain.service.common.UIDService; +import uk.gov.hmcts.ccd.domain.service.createcase.POCSubmitCaseTransaction; import uk.gov.hmcts.ccd.domain.service.createcase.SubmitCaseTransaction; import uk.gov.hmcts.ccd.domain.service.getcasedocument.CaseDocumentService; import uk.gov.hmcts.ccd.domain.service.getcasedocument.CaseDocumentTimestampService; @@ -35,11 +36,12 @@ public ContractTestSubmitCaseTransaction(DefaultCaseDetailsRepository caseDetail CaseDocumentService caseDocumentService, ApplicationParams applicationParams, CaseAccessGroupUtils caseAccessGroupUtils, - CaseDocumentTimestampService caseDocumentTimestampService) { + CaseDocumentTimestampService caseDocumentTimestampService, + POCSubmitCaseTransaction pocSubmitCaseTransaction) { super(caseDetailsRepository, caseAuditEventRepository, caseTypeService, callbackInvoker, uidService, securityClassificationService, caseDataAccessControl, messageService, caseDocumentService, applicationParams, - caseAccessGroupUtils, caseDocumentTimestampService); + caseAccessGroupUtils, caseDocumentTimestampService, pocSubmitCaseTransaction); } } diff --git a/src/main/java/uk/gov/hmcts/ccd/ApplicationParams.java b/src/main/java/uk/gov/hmcts/ccd/ApplicationParams.java index 847b92fc62..81d0781a57 100644 --- a/src/main/java/uk/gov/hmcts/ccd/ApplicationParams.java +++ b/src/main/java/uk/gov/hmcts/ccd/ApplicationParams.java @@ -235,6 +235,12 @@ public class ApplicationParams { @Value("#{'${ccd.callback.passthru-header-contexts}'.split(',')}") private List callbackPassthruHeaderContexts; + @Value("#{'${ccd.poc.case-types}'.split(',')}") + private List pocCaseTypes; + + @Value("${poc.feature.enabled}") + private boolean isPocFeatureEnabled; + public static String encode(final String stringToEncode) { try { return URLEncoder.encode(stringToEncode, "UTF-8"); @@ -629,4 +635,20 @@ public List getCallbackPassthruHeaderContexts() { public List getUploadTimestampFeaturedCaseTypes() { return uploadTimestampFeaturedCaseTypes; } + + public boolean isPocFeatureEnabled() { + return isPocFeatureEnabled; + } + + public void setPocFeatureEnabled(boolean pocFeatureEnabled) { + isPocFeatureEnabled = pocFeatureEnabled; + } + + public List getPocCaseTypes() { + return pocCaseTypes; + } + + public void setPocCaseTypes(List pocCaseTypes) { + this.pocCaseTypes = pocCaseTypes; + } } diff --git a/src/main/java/uk/gov/hmcts/ccd/clients/PocApiClient.java b/src/main/java/uk/gov/hmcts/ccd/clients/PocApiClient.java new file mode 100644 index 0000000000..3150b068a2 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/ccd/clients/PocApiClient.java @@ -0,0 +1,30 @@ +package uk.gov.hmcts.ccd.clients; + +import java.util.List; +import org.springframework.cloud.openfeign.FeignClient; +import org.springframework.http.MediaType; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestAttribute; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestHeader; +import uk.gov.hmcts.ccd.customheaders.UserAuthHeadersInterceptorConfig; +import uk.gov.hmcts.ccd.domain.model.aggregated.POCCaseEvent; +import uk.gov.hmcts.ccd.domain.model.casedataaccesscontrol.RoleAssignments; +import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; +import uk.gov.hmcts.ccd.domain.model.std.AuditEvent; + +@FeignClient(name = "pocApi", url = "${poc.apis.url}", configuration = UserAuthHeadersInterceptorConfig.class) +public interface PocApiClient { + + @GetMapping(value = "/ccd/cases/{case-ref}") + CaseDetails getCase(@PathVariable("case-ref") String caseRef, @RequestAttribute("roleAssignments") RoleAssignments roleAssignments); + + @PostMapping(value = "/ccd/cases", consumes = MediaType.APPLICATION_JSON_VALUE, + produces = MediaType.APPLICATION_JSON_VALUE) + CaseDetails createEvent(@RequestBody POCCaseEvent caseEvent, @RequestAttribute("roleAssignments") RoleAssignments roleAssignments); + + @GetMapping(value = "/ccd/cases/{case-ref}/history") + List getEvents(@PathVariable("case-ref") String caseReference, @RequestAttribute("roleAssignments") RoleAssignments roleAssignments); +} diff --git a/src/main/java/uk/gov/hmcts/ccd/customheaders/UserAuthHeadersInterceptor.java b/src/main/java/uk/gov/hmcts/ccd/customheaders/UserAuthHeadersInterceptor.java new file mode 100644 index 0000000000..377622a0c2 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/ccd/customheaders/UserAuthHeadersInterceptor.java @@ -0,0 +1,29 @@ +package uk.gov.hmcts.ccd.customheaders; + +import feign.RequestInterceptor; +import feign.RequestTemplate; +import static org.springframework.http.HttpHeaders.AUTHORIZATION; +import uk.gov.hmcts.ccd.data.SecurityUtils; + +public class UserAuthHeadersInterceptor implements RequestInterceptor { + + private static final String EXPERIMENTAL = "experimental"; + public static final String SERVICE_AUTHORIZATION = "ServiceAuthorization"; + private final SecurityUtils securityUtils; + + public UserAuthHeadersInterceptor(SecurityUtils securityUtils) { + this.securityUtils = securityUtils; + } + + @Override + public void apply(RequestTemplate template) { + if (!template.headers().containsKey(AUTHORIZATION)) { + template.header(AUTHORIZATION, securityUtils.getUserBearerToken()); + } + if (!template.headers().containsKey(SERVICE_AUTHORIZATION)) { + template.header(SERVICE_AUTHORIZATION, securityUtils.getServiceAuthorization()); + } + // TODO: will be removed once ccd cleaned in their end + template.header(EXPERIMENTAL, "true"); + } +} diff --git a/src/main/java/uk/gov/hmcts/ccd/customheaders/UserAuthHeadersInterceptorConfig.java b/src/main/java/uk/gov/hmcts/ccd/customheaders/UserAuthHeadersInterceptorConfig.java new file mode 100644 index 0000000000..f7e5559bc7 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/ccd/customheaders/UserAuthHeadersInterceptorConfig.java @@ -0,0 +1,19 @@ +package uk.gov.hmcts.ccd.customheaders; + +import feign.Retryer; +import org.springframework.context.annotation.Bean; +import uk.gov.hmcts.ccd.data.SecurityUtils; + + +public class UserAuthHeadersInterceptorConfig { + + @Bean + public UserAuthHeadersInterceptor userAuthHeadersInterceptor(SecurityUtils securityUtils) { + return new UserAuthHeadersInterceptor(securityUtils); + } + + @Bean + public Retryer retryer() { + return Retryer.NEVER_RETRY; + } +} diff --git a/src/main/java/uk/gov/hmcts/ccd/data/AuthClientsConfiguration.java b/src/main/java/uk/gov/hmcts/ccd/data/AuthClientsConfiguration.java index 8475dd21a9..c7b00995a0 100644 --- a/src/main/java/uk/gov/hmcts/ccd/data/AuthClientsConfiguration.java +++ b/src/main/java/uk/gov/hmcts/ccd/data/AuthClientsConfiguration.java @@ -5,6 +5,7 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Lazy; +import uk.gov.hmcts.ccd.clients.PocApiClient; import uk.gov.hmcts.reform.authorisation.ServiceAuthorisationApi; import uk.gov.hmcts.reform.authorisation.generators.AuthTokenGenerator; import uk.gov.hmcts.reform.authorisation.generators.AuthTokenGeneratorFactory; @@ -15,7 +16,7 @@ @Configuration @Lazy -@EnableFeignClients(basePackageClasses = {IdamApi.class, ServiceAuthorisationApi.class}) +@EnableFeignClients(basePackageClasses = {IdamApi.class, ServiceAuthorisationApi.class, PocApiClient.class}) public class AuthClientsConfiguration { @Bean diff --git a/src/main/java/uk/gov/hmcts/ccd/data/casedetails/CaseAuditEventRepository.java b/src/main/java/uk/gov/hmcts/ccd/data/casedetails/CaseAuditEventRepository.java index 24e3bd1e91..9ccd0b00c6 100644 --- a/src/main/java/uk/gov/hmcts/ccd/data/casedetails/CaseAuditEventRepository.java +++ b/src/main/java/uk/gov/hmcts/ccd/data/casedetails/CaseAuditEventRepository.java @@ -3,6 +3,7 @@ import org.hibernate.transform.Transformers; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import uk.gov.hmcts.ccd.domain.model.std.AuditEvent; import uk.gov.hmcts.ccd.endpoint.exceptions.ResourceNotFoundException; @@ -26,13 +27,19 @@ public class CaseAuditEventRepository { private static final String EVENT_NOT_FOUND = "Event not found"; private final CaseAuditEventMapper caseAuditEventMapper; + private final POCCaseAuditEventRepository pocCaseAuditEventRepository; + private final ApplicationParams applicationParams; @PersistenceContext private EntityManager em; @Inject - public CaseAuditEventRepository(final CaseAuditEventMapper caseAuditEventMapper) { + public CaseAuditEventRepository(final CaseAuditEventMapper caseAuditEventMapper, + final POCCaseAuditEventRepository pocCaseAuditEventRepository, + final ApplicationParams applicationParams) { this.caseAuditEventMapper = caseAuditEventMapper; + this.pocCaseAuditEventRepository = pocCaseAuditEventRepository; + this.applicationParams = applicationParams; } public AuditEvent set(final AuditEvent auditEvent) { @@ -42,6 +49,10 @@ public AuditEvent set(final AuditEvent auditEvent) { } public List findByCase(final CaseDetails caseDetails) { + if (applicationParams.isPocFeatureEnabled()) { + return pocCaseAuditEventRepository.findByCase(caseDetails); + } + final List resultList = em.createNamedQuery(CaseAuditEventEntity.FIND_BY_CASE) .setParameter(CaseAuditEventEntity.CASE_DATA_ID, Long.valueOf(caseDetails.getId())) .unwrap(org.hibernate.query.Query.class) diff --git a/src/main/java/uk/gov/hmcts/ccd/data/casedetails/DefaultCaseDetailsRepository.java b/src/main/java/uk/gov/hmcts/ccd/data/casedetails/DefaultCaseDetailsRepository.java index 130115ae71..644132cdf6 100644 --- a/src/main/java/uk/gov/hmcts/ccd/data/casedetails/DefaultCaseDetailsRepository.java +++ b/src/main/java/uk/gov/hmcts/ccd/data/casedetails/DefaultCaseDetailsRepository.java @@ -54,17 +54,20 @@ public class DefaultCaseDetailsRepository implements CaseDetailsRepository { private final SearchQueryFactoryOperation queryBuilder; private final CaseDetailsQueryBuilderFactory queryBuilderFactory; private final ApplicationParams applicationParams; + private final POCCaseDetailsRepository pocCaseDetailsRepository; @Inject public DefaultCaseDetailsRepository( final CaseDetailsMapper caseDetailsMapper, final SearchQueryFactoryOperation queryBuilder, final CaseDetailsQueryBuilderFactory queryBuilderFactory, - final ApplicationParams applicationParams) { + final ApplicationParams applicationParams, + final POCCaseDetailsRepository pocCaseDetailsRepository) { this.caseDetailsMapper = caseDetailsMapper; this.queryBuilder = queryBuilder; this.queryBuilderFactory = queryBuilderFactory; this.applicationParams = applicationParams; + this.pocCaseDetailsRepository = pocCaseDetailsRepository; } @Override @@ -117,17 +120,24 @@ public List findCaseReferencesByIds(final List ids) { @Override public Optional findByReference(String jurisdiction, Long caseReference) { - return findByReference(jurisdiction, caseReference.toString()); + String reference = caseReference.toString(); + return applicationParams.isPocFeatureEnabled() + ? pocCaseDetailsRepository.findByReference(jurisdiction, reference) + : findByReference(jurisdiction, reference); } @Override public Optional findByReference(String jurisdiction, String reference) { - return find(jurisdiction, null, reference).map(this.caseDetailsMapper::entityToModel); + return applicationParams.isPocFeatureEnabled() + ? pocCaseDetailsRepository.findByReference(jurisdiction, reference) + : find(jurisdiction, null, reference).map(this.caseDetailsMapper::entityToModel); } @Override public Optional findByReference(String caseReference) { - return findByReference(null, caseReference); + return applicationParams.isPocFeatureEnabled() + ? pocCaseDetailsRepository.findByReference(caseReference) + : findByReference(null, caseReference); } /** @@ -138,7 +148,10 @@ public Optional findByReference(String caseReference) { @Override @Deprecated public CaseDetails findByReference(final Long caseReference) { - return findByReference(null, caseReference).orElseThrow(() -> new ResourceNotFoundException("No case found")); + return applicationParams.isPocFeatureEnabled() + ? pocCaseDetailsRepository.findByReference(caseReference) + : findByReference(null, + caseReference).orElseThrow(() -> new ResourceNotFoundException("No case found")); } /** @@ -153,7 +166,9 @@ public CaseDetails findByReference(final Long caseReference) { public CaseDetails findUniqueCase(final String jurisdiction, final String caseTypeId, final String reference) { - return findByReference(jurisdiction, reference).orElse(null); + return applicationParams.isPocFeatureEnabled() + ? pocCaseDetailsRepository.findUniqueCase(jurisdiction, caseTypeId, reference) + : findByReference(jurisdiction, reference).orElse(null); } @Override @@ -220,6 +235,10 @@ private List findReferencesByIds(List ids) { */ @Override public Optional findByReferenceWithNoAccessControl(String reference) { + if (applicationParams.isPocFeatureEnabled()) { + return pocCaseDetailsRepository.findByReferenceWithNoAccessControl(reference); + } + CaseDetailsQueryBuilder qb = queryBuilderFactory.selectUnsecured(em); qb.whereReference(String.valueOf(reference)); return qb.getSingleResult().map(this.caseDetailsMapper::entityToModel); diff --git a/src/main/java/uk/gov/hmcts/ccd/data/casedetails/POCCaseAuditEventRepository.java b/src/main/java/uk/gov/hmcts/ccd/data/casedetails/POCCaseAuditEventRepository.java new file mode 100644 index 0000000000..4b0782ced9 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/ccd/data/casedetails/POCCaseAuditEventRepository.java @@ -0,0 +1,38 @@ +package uk.gov.hmcts.ccd.data.casedetails; + +import java.util.List; +import javax.inject.Inject; +import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.clients.PocApiClient; +import uk.gov.hmcts.ccd.data.SecurityUtils; +import uk.gov.hmcts.ccd.domain.model.casedataaccesscontrol.RoleAssignments; +import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; +import uk.gov.hmcts.ccd.domain.model.std.AuditEvent; +import uk.gov.hmcts.ccd.domain.service.casedataaccesscontrol.RoleAssignmentService; + +@Service +public class POCCaseAuditEventRepository { + + + private final PocApiClient pocApiClient; + private final SecurityUtils securityUtils; + private final RoleAssignmentService roleAssignmentService; + + + @Inject + public POCCaseAuditEventRepository(final PocApiClient pocApiClient, + final SecurityUtils securityUtils, + final RoleAssignmentService roleAssignmentService) { + this.pocApiClient = pocApiClient; + this.securityUtils = securityUtils; + this.roleAssignmentService = roleAssignmentService; + } + + public List findByCase(final CaseDetails caseDetails) { + + Long reference = caseDetails.getReference(); + RoleAssignments roleAssignments = roleAssignmentService.getRoleAssignments(securityUtils.getUserId()); + return pocApiClient.getEvents(reference.toString(), roleAssignments); + } + +} diff --git a/src/main/java/uk/gov/hmcts/ccd/data/casedetails/POCCaseDetailsRepository.java b/src/main/java/uk/gov/hmcts/ccd/data/casedetails/POCCaseDetailsRepository.java new file mode 100644 index 0000000000..851949c5ce --- /dev/null +++ b/src/main/java/uk/gov/hmcts/ccd/data/casedetails/POCCaseDetailsRepository.java @@ -0,0 +1,116 @@ +package uk.gov.hmcts.ccd.data.casedetails; + +import java.util.List; +import java.util.Map; +import java.util.Optional; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.ApplicationParams; +import uk.gov.hmcts.ccd.clients.PocApiClient; +import uk.gov.hmcts.ccd.data.SecurityUtils; +import uk.gov.hmcts.ccd.data.casedetails.search.MetaData; +import uk.gov.hmcts.ccd.data.casedetails.search.PaginatedSearchMetadata; +import uk.gov.hmcts.ccd.domain.model.casedataaccesscontrol.RoleAssignments; +import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; +import uk.gov.hmcts.ccd.domain.model.migration.MigrationParameters; +import uk.gov.hmcts.ccd.domain.service.casedataaccesscontrol.RoleAssignmentService; + +@Service +@Slf4j +public class POCCaseDetailsRepository implements CaseDetailsRepository { + + private final ApplicationParams applicationParams; + private final PocApiClient pocApiClient; + private final SecurityUtils securityUtils; + private final RoleAssignmentService roleAssignmentService; + + public POCCaseDetailsRepository(final ApplicationParams applicationParams, + final PocApiClient pocApiClient, + final SecurityUtils securityUtils, + final RoleAssignmentService roleAssignmentService) { + this.applicationParams = applicationParams; + this.pocApiClient = pocApiClient; + this.securityUtils = securityUtils; + this.roleAssignmentService = roleAssignmentService; + } + + @Override + public CaseDetails set(CaseDetails caseDetails) { + return null; + } + + @Override + public Optional findById(String jurisdiction, Long id) { + return Optional.empty(); + } + + @Override + public CaseDetails findById(Long id) { + return null; + } + + @Override + public List findCaseReferencesByIds(List ids) { + return List.of(); + } + + @Override + public Optional findByReferenceWithNoAccessControl(String reference) { + return Optional.ofNullable(getCaseDetails(reference)); + } + + @Override + public Optional findByReference(String jurisdiction, Long caseReference) { + return Optional.ofNullable(getCaseDetails(caseReference.toString())); + } + + @Override + public Optional findByReference(String jurisdiction, String reference) { + return Optional.ofNullable(getCaseDetails(reference)); + } + + @Override + public Optional findByReference(String reference) { + return Optional.ofNullable(getCaseDetails(reference)); + } + + @Override + public CaseDetails findByReference(Long caseReference) { + return getCaseDetails(caseReference.toString()); + } + + private CaseDetails getCaseDetails(String reference) { + RoleAssignments roleAssignments = roleAssignmentService.getRoleAssignments(securityUtils.getUserId()); + CaseDetails caseDetails = pocApiClient.getCase(reference, roleAssignments); + log.info("case Id {}", caseDetails.getId()); + log.info("case reference {}", caseDetails.getReference()); + if (Optional.ofNullable(caseDetails).isPresent()) { + caseDetails.setId(caseDetails.getReference().toString()); + caseDetails.setReference(Long.valueOf(reference)); + log.info("case Id after{}", caseDetails.getId()); + log.info("case reference after{}", caseDetails.getReference()); + } + return caseDetails; + } + + + @Override + public CaseDetails findUniqueCase(String jurisdictionId, String caseTypeId, String caseReference) { + return getCaseDetails(caseReference); + } + + @Override + public List findByMetaDataAndFieldData(MetaData metadata, Map dataSearchParams) { + return List.of(); + } + + @Override + public List findByParamsWithLimit(MigrationParameters migrationParameters) { + return List.of(); + } + + @Override + public PaginatedSearchMetadata getPaginatedSearchMetadata(MetaData metaData, Map dataSearchParams) { + return null; + } +} diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/model/aggregated/POCCaseEvent.java b/src/main/java/uk/gov/hmcts/ccd/domain/model/aggregated/POCCaseEvent.java new file mode 100644 index 0000000000..e884efa674 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/ccd/domain/model/aggregated/POCCaseEvent.java @@ -0,0 +1,22 @@ +package uk.gov.hmcts.ccd.domain.model.aggregated; + +import com.fasterxml.jackson.annotation.JsonCreator; +import lombok.Builder; +import lombok.Data; +import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; + +@Data +@Builder +public class POCCaseEvent { + + private CaseDetails caseDetailsBefore; + private CaseDetails caseDetails; + private POCEventDetails eventDetails; + + @JsonCreator + public POCCaseEvent(CaseDetails caseDetailsBefore, CaseDetails caseDetails, POCEventDetails eventDetails) { + this.caseDetailsBefore = caseDetailsBefore; + this.caseDetails = caseDetails; + this.eventDetails = eventDetails; + } +} diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/model/aggregated/POCEventDetails.java b/src/main/java/uk/gov/hmcts/ccd/domain/model/aggregated/POCEventDetails.java new file mode 100644 index 0000000000..14e576c9e9 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/ccd/domain/model/aggregated/POCEventDetails.java @@ -0,0 +1,25 @@ +package uk.gov.hmcts.ccd.domain.model.aggregated; + +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Builder; +import lombok.Data; + +@Data +@Builder +public class POCEventDetails { + + @JsonProperty("event_id") + private String eventId; + @JsonProperty("event_name") + private String eventName; + @JsonProperty("state_name") + private String stateName; + private String description; + private String summary; + @JsonProperty("proxied_by") + private String proxiedBy; + @JsonProperty("proxied_by_first_name") + private String proxiedByFirstName; + @JsonProperty("proxied_by_last_name") + private String proxiedByLastName; +} diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/model/std/AuditEvent.java b/src/main/java/uk/gov/hmcts/ccd/domain/model/std/AuditEvent.java index f5456a3f41..ae2206552f 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/model/std/AuditEvent.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/model/std/AuditEvent.java @@ -1,6 +1,5 @@ package uk.gov.hmcts.ccd.domain.model.std; -import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.JsonNode; import io.swagger.annotations.ApiModelProperty; @@ -18,7 +17,7 @@ @EqualsAndHashCode(callSuper = false) @NoArgsConstructor public class AuditEvent extends Event { - @JsonIgnore + @JsonProperty("event_instance_id") private Long id; @JsonProperty("user_id") private String userId; @@ -28,7 +27,7 @@ public class AuditEvent extends Event { private String userFirstName; @JsonProperty("event_name") private String eventName; - @JsonIgnore + @JsonProperty("case_data_id") private String caseDataId; @JsonProperty("created_date") private LocalDateTime createdDate; diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/aggregated/AbstractDefaultGetCaseViewOperation.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/aggregated/AbstractDefaultGetCaseViewOperation.java index 8fe4fc57ee..a15a471081 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/service/aggregated/AbstractDefaultGetCaseViewOperation.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/aggregated/AbstractDefaultGetCaseViewOperation.java @@ -1,6 +1,8 @@ package uk.gov.hmcts.ccd.domain.service.aggregated; import com.fasterxml.jackson.databind.JsonNode; +import java.util.Optional; +import lombok.extern.slf4j.Slf4j; import uk.gov.hmcts.ccd.data.definition.UIDefinitionRepository; import uk.gov.hmcts.ccd.domain.model.aggregated.CaseViewEvent; import uk.gov.hmcts.ccd.domain.model.aggregated.CaseViewField; @@ -27,6 +29,7 @@ import static uk.gov.hmcts.ccd.domain.model.definition.FieldTypeDefinition.CASE_HISTORY_VIEWER; +@Slf4j public abstract class AbstractDefaultGetCaseViewOperation { public static final String QUALIFIER = "default"; @@ -70,8 +73,9 @@ CaseTypeDefinition getCaseType(String jurisdictionId, String caseTypeId) { } CaseDetails getCaseDetails(String caseReference) { - return getCaseOperation.execute(caseReference) - .orElseThrow(() -> new CaseNotFoundException(caseReference)); + Optional caseDetails = getCaseOperation.execute(caseReference); + log.info("caseDetails is present ? {}", caseDetails.isPresent()); + return caseDetails.orElseThrow(() -> new CaseNotFoundException(caseReference)); } CaseViewTab[] getTabs(CaseDetails caseDetails, Map data) { diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/common/SecurityClassificationServiceImpl.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/common/SecurityClassificationServiceImpl.java index 8d731ab48f..002dee1f6f 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/service/common/SecurityClassificationServiceImpl.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/common/SecurityClassificationServiceImpl.java @@ -16,6 +16,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.config.JacksonUtils; import uk.gov.hmcts.ccd.data.casedetails.SecurityClassification; import uk.gov.hmcts.ccd.data.definition.CachedCaseDefinitionRepository; @@ -44,17 +45,22 @@ public class SecurityClassificationServiceImpl implements SecurityClassification private final CaseDataAccessControl caseDataAccessControl; private final CaseDefinitionRepository caseDefinitionRepository; + private final ApplicationParams applicationParams; @Autowired public SecurityClassificationServiceImpl(CaseDataAccessControl caseDataAccessControl, @Qualifier(CachedCaseDefinitionRepository.QUALIFIER) - final CaseDefinitionRepository caseDefinitionRepository) { + final CaseDefinitionRepository caseDefinitionRepository, + ApplicationParams applicationParams) { this.caseDataAccessControl = caseDataAccessControl; this.caseDefinitionRepository = caseDefinitionRepository; + this.applicationParams = applicationParams; } public Optional applyClassification(CaseDetails caseDetails) { - return applyClassification(caseDetails, false); + return applicationParams.isPocFeatureEnabled() + ? Optional.of(caseDetails) + : applyClassification(caseDetails, false); } public Optional applyClassification(CaseDetails caseDetails, boolean create) { diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/ClassifiedCreateCaseOperation.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/ClassifiedCreateCaseOperation.java index 0bbe9c4614..09075a81e2 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/ClassifiedCreateCaseOperation.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/ClassifiedCreateCaseOperation.java @@ -3,6 +3,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import uk.gov.hmcts.ccd.domain.model.std.CaseDataContent; import uk.gov.hmcts.ccd.domain.service.common.SecurityClassificationServiceImpl; @@ -12,13 +13,16 @@ public class ClassifiedCreateCaseOperation implements CreateCaseOperation { private final CreateCaseOperation createCaseOperation; private final SecurityClassificationServiceImpl classificationService; + private final ApplicationParams applicationParams; @Autowired public ClassifiedCreateCaseOperation(@Qualifier("default") CreateCaseOperation createCaseOperation, - SecurityClassificationServiceImpl classificationService) { + SecurityClassificationServiceImpl classificationService, + ApplicationParams applicationParams) { this.createCaseOperation = createCaseOperation; this.classificationService = classificationService; + this.applicationParams = applicationParams; } @Override @@ -31,6 +35,8 @@ public CaseDetails createCaseDetails(String caseTypeId, if (null == caseDetails) { return null; } - return classificationService.applyClassification(caseDetails, true).orElse(null); + return (applicationParams.isPocFeatureEnabled()) + ? caseDetails + : classificationService.applyClassification(caseDetails, true).orElse(null); } } diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/POCSubmitCaseTransaction.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/POCSubmitCaseTransaction.java new file mode 100644 index 0000000000..d6586c0de6 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/POCSubmitCaseTransaction.java @@ -0,0 +1,85 @@ +package uk.gov.hmcts.ccd.domain.service.createcase; + +import feign.FeignException; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.clients.PocApiClient; +import uk.gov.hmcts.ccd.domain.model.aggregated.IdamUser; +import uk.gov.hmcts.ccd.domain.model.aggregated.POCCaseEvent; +import uk.gov.hmcts.ccd.domain.model.aggregated.POCEventDetails; +import uk.gov.hmcts.ccd.domain.model.casedataaccesscontrol.RoleAssignments; +import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; +import uk.gov.hmcts.ccd.domain.model.definition.CaseEventDefinition; +import uk.gov.hmcts.ccd.domain.model.definition.CaseStateDefinition; +import uk.gov.hmcts.ccd.domain.model.definition.CaseTypeDefinition; +import uk.gov.hmcts.ccd.domain.model.std.Event; +import uk.gov.hmcts.ccd.domain.service.casedataaccesscontrol.RoleAssignmentService; +import uk.gov.hmcts.ccd.domain.service.common.CaseTypeService; +import uk.gov.hmcts.ccd.domain.service.stdapi.AboutToSubmitCallbackResponse; +import uk.gov.hmcts.ccd.endpoint.exceptions.CaseConcurrencyException; + +@Slf4j +@Service +public class POCSubmitCaseTransaction { + + private final CaseTypeService caseTypeService; + private final PocApiClient pocApiClient; + private final RoleAssignmentService roleAssignmentService; + + public POCSubmitCaseTransaction(final CaseTypeService caseTypeService, + final PocApiClient pocApiClient, + final RoleAssignmentService roleAssignmentService) { + this.caseTypeService = caseTypeService; + this.pocApiClient = pocApiClient; + this.roleAssignmentService = roleAssignmentService; + } + + public CaseDetails saveAuditEventForCaseDetails(AboutToSubmitCallbackResponse response, + Event event, + CaseTypeDefinition caseTypeDefinition, + IdamUser idamUser, + CaseEventDefinition caseEventDefinition, + CaseDetails newCaseDetails, + IdamUser onBehalfOfUser) { + + CaseStateDefinition caseStateDefinition = + caseTypeService.findState(caseTypeDefinition, newCaseDetails.getState()); + + POCEventDetails.POCEventDetailsBuilder eventDetails = POCEventDetails.builder() + .eventId(event.getEventId()) + .eventName(caseEventDefinition.getName()) + .summary(event.getSummary()) + .description(event.getDescription()) + .stateName(caseStateDefinition.getName()); + + if (onBehalfOfUser != null) { + + eventDetails.proxiedBy(onBehalfOfUser.getId()) + .proxiedByFirstName(onBehalfOfUser.getForename()) + .proxiedByFirstName(onBehalfOfUser.getSurname()); + } + + POCCaseEvent pocCaseEvent = POCCaseEvent.builder() + .caseDetails(newCaseDetails).eventDetails(eventDetails.build()).build(); + + + try { + RoleAssignments roleAssignments = roleAssignmentService.getRoleAssignments(idamUser.getId()); + CaseDetails caseDetails = pocApiClient.createEvent(pocCaseEvent, roleAssignments); + log.info("pocCaseDetails: {}", caseDetails); + log.info("pocCaseDetails id: {}", caseDetails.getId()); + log.info("pocCaseDetails reference before: {}", caseDetails.getReference()); + caseDetails.setId(caseDetails.getReference().toString()); + caseDetails.setReference(caseDetails.getReference()); + log.info("pocCaseDetails reference: {}", caseDetails.getReference()); + + return caseDetails; + } catch (FeignException.Conflict conflict) { + throw new CaseConcurrencyException(""" + Unfortunately we were unable to save your work to the case as \ + another action happened at the same time. + Please review the case and try again."""); + + } + } +} diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransaction.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransaction.java index 79fb34677b..5014b39246 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransaction.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransaction.java @@ -52,6 +52,7 @@ public class SubmitCaseTransaction implements AccessControl { private final ApplicationParams applicationParams; private final CaseAccessGroupUtils caseAccessGroupUtils; private final CaseDocumentTimestampService caseDocumentTimestampService; + private final POCSubmitCaseTransaction pocSubmitCaseTransaction; @Inject public SubmitCaseTransaction(@Qualifier(CachedCaseDetailsRepository.QUALIFIER) @@ -66,7 +67,8 @@ public SubmitCaseTransaction(@Qualifier(CachedCaseDetailsRepository.QUALIFIER) final CaseDocumentService caseDocumentService, final ApplicationParams applicationParams, final CaseAccessGroupUtils caseAccessGroupUtils, - final CaseDocumentTimestampService caseDocumentTimestampService + final CaseDocumentTimestampService caseDocumentTimestampService, + final POCSubmitCaseTransaction pocSubmitCaseTransaction ) { this.caseDetailsRepository = caseDetailsRepository; this.caseAuditEventRepository = caseAuditEventRepository; @@ -80,7 +82,7 @@ public SubmitCaseTransaction(@Qualifier(CachedCaseDetailsRepository.QUALIFIER) this.applicationParams = applicationParams; this.caseAccessGroupUtils = caseAccessGroupUtils; this.caseDocumentTimestampService = caseDocumentTimestampService; - + this.pocSubmitCaseTransaction = pocSubmitCaseTransaction; } @Transactional(propagation = Propagation.REQUIRES_NEW) @@ -191,14 +193,19 @@ private CaseDetails saveAuditEventForCaseDetails(AboutToSubmitCallbackResponse r auditEvent.setSignificantItem(response.getSignificantItem()); saveUserDetails(idamUser, onBehalfOfUser, auditEvent); + CaseDetails messageCaseDetails = this.applicationParams.isPocFeatureEnabled() + ? pocSubmitCaseTransaction.saveAuditEventForCaseDetails(response, + event, caseTypeDefinition, idamUser, caseEventDefinition, newCaseDetails, onBehalfOfUser) + : savedCaseDetails; + caseAuditEventRepository.set(auditEvent); messageService.handleMessage(MessageContext.builder() - .caseDetails(savedCaseDetails) + .caseDetails(messageCaseDetails) .caseTypeDefinition(caseTypeDefinition) .caseEventDefinition(caseEventDefinition) .oldState(null).build()); - return savedCaseDetails; + return messageCaseDetails; } private void saveUserDetails(IdamUser idamUser, IdamUser onBehalfOfUser, AuditEvent auditEvent) { diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/ClassifiedCreateEventOperation.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/ClassifiedCreateEventOperation.java index d82250d8ed..bb5b4637ec 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/ClassifiedCreateEventOperation.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/ClassifiedCreateEventOperation.java @@ -5,6 +5,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import uk.gov.hmcts.ccd.domain.model.std.CaseDataContent; import uk.gov.hmcts.ccd.domain.service.common.SecurityClassificationServiceImpl; @@ -14,13 +15,16 @@ public class ClassifiedCreateEventOperation implements CreateEventOperation { private final CreateEventOperation createEventOperation; private final SecurityClassificationServiceImpl classificationService; + private final ApplicationParams applicationParams; @Autowired public ClassifiedCreateEventOperation(@Qualifier("default") CreateEventOperation createEventOperation, - SecurityClassificationServiceImpl classificationService) { + SecurityClassificationServiceImpl classificationService, + ApplicationParams applicationParams) { this.createEventOperation = createEventOperation; this.classificationService = classificationService; + this.applicationParams = applicationParams; } @Override @@ -28,7 +32,9 @@ public CaseDetails createCaseEvent(String caseReference, CaseDataContent content) { final CaseDetails caseDetails = createEventOperation.createCaseEvent(caseReference, content); - return Optional.ofNullable(caseDetails) + return applicationParams.isPocFeatureEnabled() + ? caseDetails + : Optional.ofNullable(caseDetails) .flatMap(classificationService::applyClassification) .orElse(null); } diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/CreateCaseEventService.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/CreateCaseEventService.java index b50299525a..9758fa2179 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/CreateCaseEventService.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/CreateCaseEventService.java @@ -95,6 +95,7 @@ public class CreateCaseEventService { private final TimeToLiveService timeToLiveService; private final CaseLinkService caseLinkService; private final CaseDocumentTimestampService caseDocumentTimestampService; + private final POCCreateCaseEventService pocCreateCaseEventService; private final ApplicationParams applicationParams; private final CaseAccessGroupUtils caseAccessGroupUtils; @@ -130,7 +131,8 @@ public CreateCaseEventService(@Qualifier(CachedUserRepository.QUALIFIER) final U final CaseLinkService caseLinkService, final ApplicationParams applicationParams, final CaseAccessGroupUtils caseAccessGroupUtils, - final CaseDocumentTimestampService caseDocumentTimestampService) { + final CaseDocumentTimestampService caseDocumentTimestampService, + final POCCreateCaseEventService pocCreateCaseEventService) { this.userRepository = userRepository; this.caseDetailsRepository = caseDetailsRepository; @@ -162,6 +164,7 @@ public CreateCaseEventService(@Qualifier(CachedUserRepository.QUALIFIER) final U this.caseAccessGroupUtils = caseAccessGroupUtils; this.caseDocumentTimestampService = caseDocumentTimestampService; + this.pocCreateCaseEventService = pocCreateCaseEventService; } @Transactional(propagation = Propagation.REQUIRES_NEW) @@ -240,29 +243,32 @@ public CreateCaseEventResult createCaseEvent(final String caseReference, final C caseDetailsAfterCallbackWithoutHashes .setResolvedTTL(timeToLiveService.getUpdatedResolvedTTL(caseDetailsAfterCallback.getData())); - final CaseDetails savedCaseDetails = saveCaseDetails( - caseDetailsInDatabase, - caseDetailsAfterCallbackWithoutHashes, - caseEventDefinition, - newState, - timeNow - ); + boolean isPocCaseType = this.applicationParams.getPocCaseTypes() + .contains(caseDetailsInDatabase.getCaseTypeId()); - caseLinkService.updateCaseLinks(savedCaseDetails, caseTypeDefinition.getCaseFieldDefinitions()); + CaseDetails finalCaseDetails = isPocCaseType + ? pocCreateCaseEventService.saveAuditEventForCaseDetails(content.getEvent(), caseEventDefinition, + caseDetailsAfterCallbackWithoutHashes, caseTypeDefinition, caseDetailsInDatabase) + : saveCaseDetails(caseDetailsInDatabase, caseDetailsAfterCallbackWithoutHashes, caseEventDefinition, + newState, timeNow); - saveAuditEventForCaseDetails( - aboutToSubmitCallbackResponse, - content.getEvent(), - caseEventDefinition, - savedCaseDetails, - caseTypeDefinition, - timeNow, - oldState, - content.getOnBehalfOfUserToken(), - content.getOnBehalfOfId(), - securityClassificationService.getClassificationForEvent(caseTypeDefinition, - caseEventDefinition) - ); + caseLinkService.updateCaseLinks(finalCaseDetails, caseTypeDefinition.getCaseFieldDefinitions()); + + if (!isPocCaseType) { + saveAuditEventForCaseDetails( + aboutToSubmitCallbackResponse, + content.getEvent(), + caseEventDefinition, + finalCaseDetails, + caseTypeDefinition, + timeNow, + oldState, + content.getOnBehalfOfUserToken(), + content.getOnBehalfOfId(), + securityClassificationService.getClassificationForEvent(caseTypeDefinition, + caseEventDefinition) + ); + } caseDocumentService.attachCaseDocuments( caseDetails.getReferenceAsString(), @@ -273,7 +279,7 @@ public CreateCaseEventResult createCaseEvent(final String caseReference, final C return CreateCaseEventResult.caseEventWith() .caseDetailsBefore(caseDetailsInDatabase) - .savedCaseDetails(savedCaseDetails) + .savedCaseDetails(finalCaseDetails) .eventTrigger(caseEventDefinition) .build(); } @@ -329,25 +335,29 @@ public CreateCaseEventResult createCaseSystemEvent(final String caseReference, caseDetailsAfterCallback ); - final CaseDetails savedCaseDetails = saveCaseDetails( - caseDetailsInDatabase, - caseDetailsAfterCallbackWithoutHashes, - caseEventDefinition, - newState, - timeNow - ); - saveAuditEventForCaseDetails( - aboutToSubmitCallbackResponse, - event, - caseEventDefinition, - savedCaseDetails, - caseTypeDefinition, - timeNow, - oldState, - null, - null, - SecurityClassification.PUBLIC - ); + boolean isPocCaseType = this.applicationParams.getPocCaseTypes() + .contains(caseDetailsInDatabase.getCaseTypeId()); + + CaseDetails finalCaseDetails = isPocCaseType + ? pocCreateCaseEventService.saveAuditEventForCaseDetails(event, caseEventDefinition, + caseDetailsAfterCallbackWithoutHashes, caseTypeDefinition, caseDetailsInDatabase) + : saveCaseDetails(caseDetailsInDatabase, caseDetailsAfterCallbackWithoutHashes, caseEventDefinition, + newState, timeNow); + + if (!isPocCaseType) { + saveAuditEventForCaseDetails( + aboutToSubmitCallbackResponse, + event, + caseEventDefinition, + finalCaseDetails, + caseTypeDefinition, + timeNow, + oldState, + null, + null, + SecurityClassification.PUBLIC + ); + } caseDocumentService.attachCaseDocuments( caseDetails.getReferenceAsString(), @@ -358,7 +368,7 @@ public CreateCaseEventResult createCaseSystemEvent(final String caseReference, return CreateCaseEventResult.caseEventWith() .caseDetailsBefore(caseDetailsInDatabase) - .savedCaseDetails(savedCaseDetails) + .savedCaseDetails(finalCaseDetails) .eventTrigger(caseEventDefinition) .build(); } diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/POCCreateCaseEventService.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/POCCreateCaseEventService.java new file mode 100644 index 0000000000..7ae5648f1a --- /dev/null +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/createevent/POCCreateCaseEventService.java @@ -0,0 +1,81 @@ +package uk.gov.hmcts.ccd.domain.service.createevent; + +import feign.FeignException; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.clients.PocApiClient; +import uk.gov.hmcts.ccd.data.SecurityUtils; +import uk.gov.hmcts.ccd.domain.model.aggregated.POCCaseEvent; +import uk.gov.hmcts.ccd.domain.model.aggregated.POCEventDetails; +import uk.gov.hmcts.ccd.domain.model.casedataaccesscontrol.RoleAssignments; +import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; +import uk.gov.hmcts.ccd.domain.model.definition.CaseEventDefinition; +import uk.gov.hmcts.ccd.domain.model.definition.CaseStateDefinition; +import uk.gov.hmcts.ccd.domain.model.definition.CaseTypeDefinition; +import uk.gov.hmcts.ccd.domain.model.std.Event; +import uk.gov.hmcts.ccd.domain.service.casedataaccesscontrol.RoleAssignmentService; +import uk.gov.hmcts.ccd.domain.service.common.CaseTypeService; +import uk.gov.hmcts.ccd.domain.service.message.MessageService; +import uk.gov.hmcts.ccd.endpoint.exceptions.CaseConcurrencyException; + +@Slf4j +@Service +public class POCCreateCaseEventService { + + private final CaseTypeService caseTypeService; + private final PocApiClient pocApiClient; + private final MessageService messageService; + private final SecurityUtils securityUtils; + private final RoleAssignmentService roleAssignmentService; + + public POCCreateCaseEventService(final CaseTypeService caseTypeService, + final PocApiClient pocApiClient, + @Qualifier("caseEventMessageService") final MessageService messageService, + final SecurityUtils securityUtils, + final RoleAssignmentService roleAssignmentService) { + this.caseTypeService = caseTypeService; + this.pocApiClient = pocApiClient; + this.messageService = messageService; + this.securityUtils = securityUtils; + this.roleAssignmentService = roleAssignmentService; + } + + public CaseDetails saveAuditEventForCaseDetails(final Event event, + final CaseEventDefinition caseEventDefinition, + final CaseDetails caseDetails, + final CaseTypeDefinition caseTypeDefinition, + final CaseDetails caseDetailsBefore + ) { + + CaseStateDefinition caseStateDefinition = + caseTypeService.findState(caseTypeDefinition, caseDetails.getState()); + + POCEventDetails.POCEventDetailsBuilder eventDetails = POCEventDetails.builder() + .eventId(event.getEventId()) + .eventName(caseEventDefinition.getName()) + .summary(event.getSummary()) + .description(event.getDescription()) + .stateName(caseStateDefinition.getName()); + + //TODO Significant item is not yet set + //auditEvent.setSignificantItem(aboutToSubmitCallbackResponse.getSignificantItem()); + + POCCaseEvent pocCaseEvent = POCCaseEvent.builder() + .caseDetailsBefore(caseDetailsBefore) + .caseDetails(caseDetails) + .eventDetails(eventDetails.build()) + .build(); + + try { + RoleAssignments roleAssignments = roleAssignmentService.getRoleAssignments(securityUtils.getUserId()); + return pocApiClient.createEvent(pocCaseEvent, roleAssignments); + } catch (FeignException.Conflict conflict) { + throw new CaseConcurrencyException(""" + Unfortunately we were unable to save your work to the case as \ + another action happened at the same time. + Please review the case and try again."""); + + } + } +} diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/getcase/ClassifiedGetCaseOperation.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/getcase/ClassifiedGetCaseOperation.java index fda199318b..804bb45b33 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/service/getcase/ClassifiedGetCaseOperation.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/getcase/ClassifiedGetCaseOperation.java @@ -2,6 +2,7 @@ import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import java.util.Optional; @@ -14,22 +15,29 @@ public class ClassifiedGetCaseOperation implements GetCaseOperation { private final GetCaseOperation getCaseOperation; private final SecurityClassificationServiceImpl classificationService; + private final ApplicationParams applicationParams; public ClassifiedGetCaseOperation(@Qualifier("default") GetCaseOperation getCaseOperation, - SecurityClassificationServiceImpl classificationService) { + SecurityClassificationServiceImpl classificationService, + ApplicationParams applicationParams) { this.getCaseOperation = getCaseOperation; this.classificationService = classificationService; + this.applicationParams = applicationParams; } @Override public Optional execute(String jurisdictionId, String caseTypeId, String caseReference) { - return getCaseOperation.execute(jurisdictionId, caseTypeId, caseReference) - .flatMap(classificationService::applyClassification); + Optional caseDetails = getCaseOperation.execute(jurisdictionId, caseTypeId, caseReference); + return applicationParams.isPocFeatureEnabled() + ? caseDetails + : caseDetails.flatMap(classificationService::applyClassification); } @Override public Optional execute(String caseReference) { - return getCaseOperation.execute(caseReference) - .flatMap(classificationService::applyClassification); + return applicationParams.isPocFeatureEnabled() + ? getCaseOperation.execute(caseReference) + : getCaseOperation.execute(caseReference) + .flatMap(classificationService::applyClassification); } } diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/getevents/DefaultGetEventsOperation.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/getevents/DefaultGetEventsOperation.java index 04387a9ccc..4d5a2f9a8a 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/service/getevents/DefaultGetEventsOperation.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/getevents/DefaultGetEventsOperation.java @@ -6,6 +6,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.data.casedetails.CaseAuditEventRepository; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import uk.gov.hmcts.ccd.domain.model.std.AuditEvent; @@ -22,6 +23,7 @@ public class DefaultGetEventsOperation implements GetEventsOperation { private final CaseAuditEventRepository auditEventRepository; private final GetCaseOperation getCaseOperation; private final UIDService uidService; + private final ApplicationParams applicationParams; private static final String RESOURCE_NOT_FOUND // = "No case found ( jurisdiction = '%s', case type id = '%s', case reference = '%s' )"; private static final String CASE_RESOURCE_NOT_FOUND // @@ -29,11 +31,15 @@ public class DefaultGetEventsOperation implements GetEventsOperation { private static final String CASE_EVENT_NOT_FOUND = "Case audit events not found"; @Autowired - public DefaultGetEventsOperation(CaseAuditEventRepository auditEventRepository, @Qualifier( - CreatorGetCaseOperation.QUALIFIER) final GetCaseOperation getCaseOperation, UIDService uidService) { + public DefaultGetEventsOperation( + CaseAuditEventRepository auditEventRepository, + @Qualifier(CreatorGetCaseOperation.QUALIFIER) final GetCaseOperation getCaseOperation, + UIDService uidService, + final ApplicationParams applicationParams) { this.auditEventRepository = auditEventRepository; this.getCaseOperation = getCaseOperation; this.uidService = uidService; + this.applicationParams = applicationParams; } @Override @@ -65,7 +71,10 @@ public List getEvents(String caseReference) { @Override public Optional getEvent(CaseDetails caseDetails, String caseTypeId, Long eventId) { + if (applicationParams.isPocFeatureEnabled()) { + return getEvents(caseDetails).stream().filter(event -> event.getId().equals(eventId)).findFirst(); + } return auditEventRepository.findByEventId(eventId).map(Optional::of) - .orElseThrow(() -> new ResourceNotFoundException(CASE_EVENT_NOT_FOUND)); + .orElseThrow(() -> new ResourceNotFoundException(CASE_EVENT_NOT_FOUND)); } } diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/search/elasticsearch/security/ClassifiedCaseSearchOperation.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/search/elasticsearch/security/ClassifiedCaseSearchOperation.java index 425561f4bc..d678a52704 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/service/search/elasticsearch/security/ClassifiedCaseSearchOperation.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/search/elasticsearch/security/ClassifiedCaseSearchOperation.java @@ -6,6 +6,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import uk.gov.hmcts.ccd.domain.model.search.CaseSearchResult; import uk.gov.hmcts.ccd.domain.service.common.SecurityClassificationServiceImpl; @@ -18,14 +19,17 @@ public class ClassifiedCaseSearchOperation implements CaseSearchOperation { private final CaseSearchOperation caseSearchOperation; private final SecurityClassificationServiceImpl classificationService; + private final ApplicationParams applicationParams; @Autowired public ClassifiedCaseSearchOperation(@Qualifier(ElasticsearchCaseSearchOperation.QUALIFIER) CaseSearchOperation caseSearchOperation, - SecurityClassificationServiceImpl classificationService) { + SecurityClassificationServiceImpl classificationService, + ApplicationParams applicationParams) { this.caseSearchOperation = caseSearchOperation; this.classificationService = classificationService; + this.applicationParams = applicationParams; } @Override @@ -36,12 +40,14 @@ public CaseSearchResult execute(CrossCaseTypeSearchRequest request, boolean data return new CaseSearchResult(); } - List classifiedCases = results.getCases() - .stream() - .map(classificationService::applyClassification) - .filter(Optional::isPresent) - .map(Optional::get) - .collect(Collectors.toList()); + List classifiedCases = applicationParams.isPocFeatureEnabled() + ? results.getCases() + : results.getCases() + .stream() + .map(classificationService::applyClassification) + .filter(Optional::isPresent) + .map(Optional::get) + .collect(Collectors.toList()); return new CaseSearchResult(results.getTotal(), classifiedCases, results.getCaseTypesResults()); diff --git a/src/main/java/uk/gov/hmcts/ccd/domain/service/startevent/ClassifiedStartEventOperation.java b/src/main/java/uk/gov/hmcts/ccd/domain/service/startevent/ClassifiedStartEventOperation.java index 73d40466ba..0bcc03aabf 100644 --- a/src/main/java/uk/gov/hmcts/ccd/domain/service/startevent/ClassifiedStartEventOperation.java +++ b/src/main/java/uk/gov/hmcts/ccd/domain/service/startevent/ClassifiedStartEventOperation.java @@ -6,6 +6,7 @@ import com.google.common.collect.Maps; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.data.definition.CachedCaseDefinitionRepository; import uk.gov.hmcts.ccd.data.definition.CaseDefinitionRepository; import uk.gov.hmcts.ccd.data.draft.CachedDraftGateway; @@ -28,18 +29,21 @@ public class ClassifiedStartEventOperation implements StartEventOperation { private final CaseDefinitionRepository caseDefinitionRepository; private final CaseDataService caseDataService; private final DraftGateway draftGateway; + private final ApplicationParams applicationParams; public ClassifiedStartEventOperation(@Qualifier("default") StartEventOperation startEventOperation, SecurityClassificationServiceImpl classificationService, @Qualifier(CachedCaseDefinitionRepository.QUALIFIER) final CaseDefinitionRepository caseDefinitionRepository, final CaseDataService caseDataService, - @Qualifier(CachedDraftGateway.QUALIFIER) final DraftGateway draftGateway) { + @Qualifier(CachedDraftGateway.QUALIFIER) final DraftGateway draftGateway, + ApplicationParams applicationParams) { this.startEventOperation = startEventOperation; this.classificationService = classificationService; this.caseDefinitionRepository = caseDefinitionRepository; this.caseDataService = caseDataService; this.draftGateway = draftGateway; + this.applicationParams = applicationParams; } @Override @@ -86,10 +90,14 @@ private void deduceDefaultClassificationIfCaseDetailsPresent(String caseTypeId, private StartEventResult applyClassificationIfCaseDetailsExist(String caseReference, StartEventResult startEventResult) { + if (applicationParams.isPocFeatureEnabled()) { + return startEventResult; + } + CaseDetails caseDetails = startEventResult.getCaseDetails(); if (null != caseDetails) { startEventResult.setCaseDetails(classificationService.applyClassification(caseDetails) - .orElseThrow(() -> new CaseNotFoundException(caseReference))); + .orElseThrow(() -> new CaseNotFoundException(caseReference))); } return startEventResult; } diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties index ae01f5e8b2..6dc9ecb1a6 100644 --- a/src/main/resources/application.properties +++ b/src/main/resources/application.properties @@ -293,3 +293,7 @@ reference.data.cache.refresh.rate.cron=0 0 4 * * ? definition-store.retry.maxAttempts=${DEFINITION_STORE_RETRY_MAX_ATTEMPTS:3} definition-store.retry.maxDelay=${DEFINITION_STORE_RETRY_MAX_DELAY:1000} + +ccd.poc.case-types=${CCD_POC_CASE_TYPES:CIVIL} +poc.apis.url=${POC_APIS_URL:http://localhost:4013} +poc.feature.enabled=${POC_FEATURE_ENABLED:false} \ No newline at end of file diff --git a/src/test/java/uk/gov/hmcts/ccd/data/caseaccess/DefaultCaseUserRepositoryTest.java b/src/test/java/uk/gov/hmcts/ccd/data/caseaccess/DefaultCaseUserRepositoryTest.java index 014e9a169f..b81409f5fc 100644 --- a/src/test/java/uk/gov/hmcts/ccd/data/caseaccess/DefaultCaseUserRepositoryTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/data/caseaccess/DefaultCaseUserRepositoryTest.java @@ -26,6 +26,7 @@ import static org.powermock.api.mockito.PowerMockito.doReturn; @Transactional + public class DefaultCaseUserRepositoryTest extends WireMockBaseTest { private static final String COUNT_CASE_USERS = diff --git a/src/test/java/uk/gov/hmcts/ccd/data/casedetails/DefaultCaseDetailsRepositoryTest.java b/src/test/java/uk/gov/hmcts/ccd/data/casedetails/DefaultCaseDetailsRepositoryTest.java index 6aa5d1389e..c450f28502 100644 --- a/src/test/java/uk/gov/hmcts/ccd/data/casedetails/DefaultCaseDetailsRepositoryTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/data/casedetails/DefaultCaseDetailsRepositoryTest.java @@ -109,6 +109,9 @@ public class DefaultCaseDetailsRepositoryTest extends WireMockBaseTest { @Qualifier(DefaultCaseDetailsRepository.QUALIFIER) private CaseDetailsRepository caseDetailsRepository; + @MockBean + private POCCaseDetailsRepository pocCaseDetailsRepository; + @Inject private ApplicationParams applicationParams; @@ -140,7 +143,7 @@ public void setShouldThrowCaseConcurrencyException() throws NoSuchFieldException DefaultCaseDetailsRepository defaultCaseDetailsRepository = new DefaultCaseDetailsRepository(caseDetailsMapper, null, null, - applicationParams); + applicationParams, pocCaseDetailsRepository); Field emField = DefaultCaseDetailsRepository.class.getDeclaredField("em"); emField.setAccessible(true); diff --git a/src/test/java/uk/gov/hmcts/ccd/domain/service/callbacks/CallbackInvokerWireMockTest.java b/src/test/java/uk/gov/hmcts/ccd/domain/service/callbacks/CallbackInvokerWireMockTest.java index d3e0a9d0f0..512b6a4bff 100644 --- a/src/test/java/uk/gov/hmcts/ccd/domain/service/callbacks/CallbackInvokerWireMockTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/domain/service/callbacks/CallbackInvokerWireMockTest.java @@ -34,7 +34,7 @@ @FixMethodOrder(MethodSorters.NAME_ASCENDING) @TestPropertySource(properties = { - "http.client.read.timeout=500" + "http.client.read.timeout=500", "poc.feature.enabled=false" }) public class CallbackInvokerWireMockTest extends WireMockBaseTest { diff --git a/src/test/java/uk/gov/hmcts/ccd/domain/service/common/SecurityClassificationServiceTest.java b/src/test/java/uk/gov/hmcts/ccd/domain/service/common/SecurityClassificationServiceTest.java index 36e3bcd0de..f04b17571d 100644 --- a/src/test/java/uk/gov/hmcts/ccd/domain/service/common/SecurityClassificationServiceTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/domain/service/common/SecurityClassificationServiceTest.java @@ -19,6 +19,7 @@ import org.springframework.security.core.Authentication; import org.springframework.security.core.context.SecurityContext; import org.springframework.security.core.context.SecurityContextHolder; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.config.JacksonUtils; import uk.gov.hmcts.ccd.data.casedetails.SecurityClassification; import uk.gov.hmcts.ccd.data.definition.CaseDefinitionRepository; @@ -77,6 +78,8 @@ public class SecurityClassificationServiceTest { @Mock private CaseDefinitionRepository caseDefinitionRepository; + @Mock + private ApplicationParams applicationParams; private CaseDetails caseDetails; @@ -90,7 +93,8 @@ public void setUp() { SecurityContextHolder.setContext(securityContext); securityClassificationService = spy(new SecurityClassificationServiceImpl(caseDataAccessControl, - caseDefinitionRepository)); + caseDefinitionRepository, applicationParams)); + when(applicationParams.isPocFeatureEnabled()).thenReturn(false); } @Nested diff --git a/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/ClassifiedCreateCaseOperationTest.java b/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/ClassifiedCreateCaseOperationTest.java index 75876ee8e3..b3391ed37f 100644 --- a/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/ClassifiedCreateCaseOperationTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/ClassifiedCreateCaseOperationTest.java @@ -4,7 +4,9 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.mockito.Mock; +import static org.mockito.Mockito.when; import org.mockito.MockitoAnnotations; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import uk.gov.hmcts.ccd.domain.model.std.CaseDataContent; @@ -33,7 +35,8 @@ class ClassifiedCreateCaseOperationTest { @Mock private SecurityClassificationServiceImpl classificationService; - + @Mock + private ApplicationParams applicationParams; private ClassifiedCreateCaseOperation classifiedCreateCaseOperation; private CaseDetails caseDetails; private CaseDetails classifiedCase; @@ -50,7 +53,9 @@ void setUp() { classifiedCase = new CaseDetails(); doReturn(Optional.of(classifiedCase)).when(classificationService).applyClassification(caseDetails, true); - classifiedCreateCaseOperation = new ClassifiedCreateCaseOperation(createCaseOperation, classificationService); + classifiedCreateCaseOperation = new ClassifiedCreateCaseOperation(createCaseOperation, + classificationService, applicationParams); + when(applicationParams.isPocFeatureEnabled()).thenReturn(false); } @Test diff --git a/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransactionCaseAccessGroupTest.java b/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransactionCaseAccessGroupTest.java index d91c9fcd16..f1c7c2b34d 100644 --- a/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransactionCaseAccessGroupTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransactionCaseAccessGroupTest.java @@ -132,6 +132,8 @@ class SubmitCaseTransactionCaseAccessGroupTest { @Mock private ApplicationParams applicationParams; + @Mock + private POCSubmitCaseTransaction pocSubmitCaseTransaction; @InjectMocks private SubmitCaseTransaction submitCaseTransaction; @@ -164,7 +166,8 @@ void setup() throws IOException { caseDocumentService, applicationParams, caseAccessGroupUtils, - caseDocumentTimestampService + caseDocumentTimestampService, + pocSubmitCaseTransaction ); idamUser = buildIdamUser(); diff --git a/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransactionTest.java b/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransactionTest.java index 07c7039512..138ce8ec2d 100644 --- a/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransactionTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/domain/service/createcase/SubmitCaseTransactionTest.java @@ -130,6 +130,8 @@ class SubmitCaseTransactionTest { private CaseStateDefinition state; @Mock private ApplicationParams applicationParams; + @Mock + private POCSubmitCaseTransaction pocSubmitCaseTransaction; private CaseAccessGroupUtils caseAccessGroupUtils; private ObjectMapper objectMapper; @@ -153,8 +155,8 @@ void setup() { caseDocumentService, applicationParams, caseAccessGroupUtils, - caseDocumentTimestampService - + caseDocumentTimestampService, + pocSubmitCaseTransaction ); idamUser = buildIdamUser(); diff --git a/src/test/java/uk/gov/hmcts/ccd/domain/service/createevent/ClassifiedCreateEventOperationTest.java b/src/test/java/uk/gov/hmcts/ccd/domain/service/createevent/ClassifiedCreateEventOperationTest.java index f1014571b4..192a4815c5 100644 --- a/src/test/java/uk/gov/hmcts/ccd/domain/service/createevent/ClassifiedCreateEventOperationTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/domain/service/createevent/ClassifiedCreateEventOperationTest.java @@ -4,7 +4,9 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.mockito.Mock; +import static org.mockito.Mockito.when; import org.mockito.MockitoAnnotations; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import uk.gov.hmcts.ccd.domain.model.std.CaseDataContent; import uk.gov.hmcts.ccd.domain.service.common.SecurityClassificationServiceImpl; @@ -36,6 +38,8 @@ class ClassifiedCreateEventOperationTest { @Mock private SecurityClassificationServiceImpl classificationService; + @Mock + private ApplicationParams applicationParams; private ClassifiedCreateEventOperation classifiedCreateEventOperation; private CaseDetails caseDetails; @@ -55,7 +59,8 @@ void setUp() { doReturn(Optional.of(classifiedCase)).when(classificationService).applyClassification(caseDetails); classifiedCreateEventOperation = - new ClassifiedCreateEventOperation(createEventOperation, classificationService); + new ClassifiedCreateEventOperation(createEventOperation, classificationService, applicationParams); + when(applicationParams.isPocFeatureEnabled()).thenReturn(false); } @Test diff --git a/src/test/java/uk/gov/hmcts/ccd/domain/service/getcase/ClassifiedGetCaseOperationTest.java b/src/test/java/uk/gov/hmcts/ccd/domain/service/getcase/ClassifiedGetCaseOperationTest.java index 96d458491e..ba37d436f7 100644 --- a/src/test/java/uk/gov/hmcts/ccd/domain/service/getcase/ClassifiedGetCaseOperationTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/domain/service/getcase/ClassifiedGetCaseOperationTest.java @@ -5,7 +5,9 @@ import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.mockito.Mock; +import static org.mockito.Mockito.when; import org.mockito.MockitoAnnotations; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import java.util.Optional; @@ -28,7 +30,8 @@ class ClassifiedGetCaseOperationTest { @Mock private GetCaseOperation getCaseOperation; - + @Mock + private ApplicationParams applicationParams; @Mock private SecurityClassificationServiceImpl classificationService; @@ -47,7 +50,9 @@ void setUp() { classifiedDetails = Optional.of(new CaseDetails()); doReturn(classifiedDetails).when(classificationService).applyClassification(caseDetails.get()); - classifiedGetCaseOperation = new ClassifiedGetCaseOperation(getCaseOperation, classificationService); + classifiedGetCaseOperation = new ClassifiedGetCaseOperation(getCaseOperation, + classificationService, applicationParams); + when(applicationParams.isPocFeatureEnabled()).thenReturn(false); } @Nested diff --git a/src/test/java/uk/gov/hmcts/ccd/domain/service/getevents/DefaultGetEventsOperationTest.java b/src/test/java/uk/gov/hmcts/ccd/domain/service/getevents/DefaultGetEventsOperationTest.java index 41dd614e80..36654a3418 100644 --- a/src/test/java/uk/gov/hmcts/ccd/domain/service/getevents/DefaultGetEventsOperationTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/domain/service/getevents/DefaultGetEventsOperationTest.java @@ -5,6 +5,7 @@ import org.junit.jupiter.api.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.data.casedetails.CaseAuditEventRepository; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import uk.gov.hmcts.ccd.domain.model.std.AuditEvent; @@ -39,6 +40,8 @@ class DefaultGetEventsOperationTest { private GetCaseOperation getCaseOperation; @Mock private UIDService uidService; + @Mock + private ApplicationParams applicationParams; private DefaultGetEventsOperation listEventsOperation; private CaseDetails caseDetails; @@ -53,7 +56,8 @@ void setUp() { doReturn(EVENTS).when(auditEventRepository).findByCase(caseDetails); - listEventsOperation = new DefaultGetEventsOperation(auditEventRepository, getCaseOperation, uidService); + listEventsOperation + = new DefaultGetEventsOperation(auditEventRepository, getCaseOperation, uidService, applicationParams); event = new AuditEvent(); } diff --git a/src/test/java/uk/gov/hmcts/ccd/domain/service/search/elasticsearch/security/ClassifiedCaseSearchOperationTest.java b/src/test/java/uk/gov/hmcts/ccd/domain/service/search/elasticsearch/security/ClassifiedCaseSearchOperationTest.java index 70068674c3..cc56098757 100644 --- a/src/test/java/uk/gov/hmcts/ccd/domain/service/search/elasticsearch/security/ClassifiedCaseSearchOperationTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/domain/service/search/elasticsearch/security/ClassifiedCaseSearchOperationTest.java @@ -8,6 +8,7 @@ import org.junit.jupiter.api.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; +import uk.gov.hmcts.ccd.ApplicationParams; import uk.gov.hmcts.ccd.domain.model.definition.CaseDetails; import uk.gov.hmcts.ccd.domain.model.search.CaseSearchResult; import uk.gov.hmcts.ccd.domain.service.common.SecurityClassificationServiceImpl; @@ -35,6 +36,8 @@ class ClassifiedCaseSearchOperationTest { @Mock private CaseSearchOperation searchOperation; + @Mock + private ApplicationParams applicationParams; @Mock private SecurityClassificationServiceImpl classificationService; @@ -52,7 +55,8 @@ void setUp() { doReturn(Optional.of(classifiedCase1)).when(classificationService).applyClassification(case1); doReturn(Optional.of(classifiedCase2)).when(classificationService).applyClassification(case2); - classifiedSearchOperation = new ClassifiedCaseSearchOperation(searchOperation, classificationService); + classifiedSearchOperation = new ClassifiedCaseSearchOperation(searchOperation, + classificationService, applicationParams); } @Test diff --git a/src/test/java/uk/gov/hmcts/ccd/domain/service/startevent/ClassifiedStartEventOperationTest.java b/src/test/java/uk/gov/hmcts/ccd/domain/service/startevent/ClassifiedStartEventOperationTest.java index 6724672bfc..d67fbef9d8 100644 --- a/src/test/java/uk/gov/hmcts/ccd/domain/service/startevent/ClassifiedStartEventOperationTest.java +++ b/src/test/java/uk/gov/hmcts/ccd/domain/service/startevent/ClassifiedStartEventOperationTest.java @@ -11,6 +11,7 @@ import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import uk.gov.hmcts.ccd.ApplicationParams; import static uk.gov.hmcts.ccd.domain.service.common.TestBuildersUtil.CaseDetailsBuilder.newCaseDetails; import static uk.gov.hmcts.ccd.domain.service.common.TestBuildersUtil.CaseTypeBuilder.newCaseType; @@ -52,6 +53,8 @@ class ClassifiedStartEventOperationTest { @Mock private DraftGateway draftGateway; + @Mock + private ApplicationParams applicationParams; private ClassifiedStartEventOperation classifiedStartEventOperation; @@ -73,10 +76,12 @@ void setUp() { doReturn(Optional.of(classifiedDetails)).when(classificationService).applyClassification(caseDetails); classifiedStartEventOperation = new ClassifiedStartEventOperation(startEventOperation, - classificationService, - caseDefinitionRepository, - caseDataService, - draftGateway); + classificationService, + caseDefinitionRepository, + caseDataService, + draftGateway, + applicationParams); + when(applicationParams.isPocFeatureEnabled()).thenReturn(false); } @Nested diff --git a/src/test/resources/test.properties b/src/test/resources/test.properties index 3071a236a8..6c2235c1a8 100644 --- a/src/test/resources/test.properties +++ b/src/test/resources/test.properties @@ -49,3 +49,6 @@ reference.data.cache.refresh.rate.cron=- definition-store.retry.maxAttempts=5 definition-store.retry.maxDelay=100 +poc.feature.enabled=false +ccd.poc.case-types=CIVIL +poc.apis.url=http://localhost:4013