HMAI-308-person-responsible-filter (#749)

* Person responsible officer endpoint filter support

* Added missing status code schema decorator

* fixed service test

Author: wcdkj

src/main/kotlin/uk/gov/justice/digital/hmpps/hmppsintegrationapi/controllers/v1/person/PersonResponsibleOfficerController.kt

@@ -6,16 +6,18 @@ import io.swagger.v3.oas.annotations.media.Content
 import io.swagger.v3.oas.annotations.media.Schema
 import io.swagger.v3.oas.annotations.responses.ApiResponse
 import io.swagger.v3.oas.annotations.tags.Tag
+import jakarta.validation.ValidationException
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.RequestAttribute
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.exception.EntityNotFoundException
-import uk.gov.justice.digital.hmpps.hmppsintegrationapi.extensions.decodeUrlCharacters
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.DataResponse
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.PersonResponsibleOfficer
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.UpstreamApiError
+import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.roleconfig.ConsumerFilters
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.services.GetCommunityOffenderManagerForPersonService
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.services.GetPrisonOffenderManagerForPersonService
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.services.internal.AuditService
@@ -28,21 +30,26 @@ class PersonResponsibleOfficerController(
   @Autowired val getPrisonOffenderManagerForPersonService: GetPrisonOffenderManagerForPersonService,
   @Autowired val getCommunityOffenderManagerForPersonService: GetCommunityOffenderManagerForPersonService,
 ) {
-  @GetMapping("{encodedHmppsId}/person-responsible-officer")
+  @GetMapping("{hmppsId}/person-responsible-officer")
   @Operation(
     summary = "Returns the person responsible officer associated with a person.",
     responses = [
       ApiResponse(responseCode = "200", useReturnTypeSchema = true, description = "Successfully found the person responsible officer for a person with the provided HMPPS ID."),
       ApiResponse(responseCode = "404", content = [Content(schema = Schema(ref = "#/components/schemas/PersonNotFound"))]),
+      ApiResponse(responseCode = "400", content = [Content(schema = Schema(ref = "#/components/schemas/BadRequest"))]),
       ApiResponse(responseCode = "500", content = [Content(schema = Schema(ref = "#/components/schemas/InternalServerError"))]),
     ],
   )
   fun getPersonResponsibleOfficer(
-    @Parameter(description = "A URL-encoded HMPPS identifier", example = "2008%2F0545166T") @PathVariable encodedHmppsId: String,
+    @Parameter(description = "A HMPPS identifier") @PathVariable hmppsId: String,
+    @RequestAttribute filters: ConsumerFilters?,
   ): DataResponse<PersonResponsibleOfficer> {
-    val hmppsId = encodedHmppsId.decodeUrlCharacters()
-    val prisonOffenderManager = getPrisonOffenderManagerForPersonService.execute(hmppsId)
-    val communityOffenderManager = getCommunityOffenderManagerForPersonService.execute(hmppsId)
+    val prisonOffenderManager = getPrisonOffenderManagerForPersonService.execute(hmppsId, filters)
+    val communityOffenderManager = getCommunityOffenderManagerForPersonService.execute(hmppsId, filters)
+
+    if (prisonOffenderManager.hasError(UpstreamApiError.Type.BAD_REQUEST) || communityOffenderManager.hasError(UpstreamApiError.Type.BAD_REQUEST)) {
+      throw ValidationException("Invalid HMPPS ID: $hmppsId")
+    }
 
     if (prisonOffenderManager.hasError(UpstreamApiError.Type.ENTITY_NOT_FOUND)) {
       throw EntityNotFoundException("Could not find prison offender manager related to id: $hmppsId")

src/main/kotlin/uk/gov/justice/digital/hmpps/hmppsintegrationapi/services/GetCommunityOffenderManagerForPersonService.kt

@@ -5,14 +5,18 @@ import org.springframework.stereotype.Service
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.gateways.NDeliusGateway
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.CommunityOffenderManager
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.Response
+import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.roleconfig.ConsumerFilters
 
 @Service
 class GetCommunityOffenderManagerForPersonService(
   @Autowired val getPersonService: GetPersonService,
   @Autowired val nDeliusGateway: NDeliusGateway,
 ) {
-  fun execute(hmppsId: String): Response<CommunityOffenderManager> {
-    val personResponse = getPersonService.execute(hmppsId = hmppsId)
+  fun execute(
+    hmppsId: String,
+    filters: ConsumerFilters?,
+  ): Response<CommunityOffenderManager> {
+    val personResponse = getPersonService.getPersonWithPrisonFilter(hmppsId, filters)
 
     val deliusCrn = personResponse.data?.identifiers?.deliusCrn
     var nDeliusMappaDetailResponse: Response<CommunityOffenderManager> = Response(data = CommunityOffenderManager())

src/main/kotlin/uk/gov/justice/digital/hmpps/hmppsintegrationapi/services/GetPrisonOffenderManagerForPersonService.kt

@@ -5,15 +5,20 @@ import org.springframework.stereotype.Service
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.gateways.ManagePOMCaseGateway
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.PrisonOffenderManager
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.Response
+import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.roleconfig.ConsumerFilters
 
 @Service
 class GetPrisonOffenderManagerForPersonService(
   @Autowired val getPersonService: GetPersonService,
   @Autowired val managePOMCaseGateway: ManagePOMCaseGateway,
 ) {
-  fun execute(hmppsId: String): Response<PrisonOffenderManager> {
-    val personResponse = getPersonService.execute(hmppsId = hmppsId)
-    val nomisNumber = personResponse.data?.identifiers?.nomisNumber
+  fun execute(
+    hmppsId: String,
+    filters: ConsumerFilters?,
+  ): Response<PrisonOffenderManager> {
+    val personResponse = getPersonService.getNomisNumberWithPrisonFilter(hmppsId, filters)
+
+    val nomisNumber = personResponse.data?.nomisNumber
     var prisonOffenderManager: Response<PrisonOffenderManager> = Response(data = PrisonOffenderManager())
 
     if (nomisNumber != null) {

src/main/resources/globals.yml

@@ -19,6 +19,7 @@ globals:
         - "/v1/persons/.*/cell-location"
         - "/v1/persons/.*/risks/categories"
         - "/v1/persons/.*/sentences"
+        - "/v1/persons/.*/person-responsible-officer"
         - "/v1/persons/.*/protected-characteristics"
         - "/v1/persons/.*/reported-adjudications"
         - "/v1/prison/prisoners"

src/test/kotlin/uk/gov/justice/digital/hmpps/hmppsintegrationapi/controllers/v1/person/PersonResponsibleOfficerControllerTest.kt

@@ -24,8 +24,6 @@ import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.Response
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.services.GetCommunityOffenderManagerForPersonService
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.services.GetPrisonOffenderManagerForPersonService
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.services.internal.AuditService
-import java.net.URLEncoder
-import java.nio.charset.StandardCharsets
 
 @WebMvcTest(controllers = [PersonResponsibleOfficerController::class])
 @ActiveProfiles("test")
@@ -36,16 +34,16 @@ internal class PersonResponsibleOfficerControllerTest(
   @MockitoBean val getPrisonOffenderManagerForPersonService: GetPrisonOffenderManagerForPersonService,
 ) : DescribeSpec() {
   init {
-    val hmppsId = "9999/11111A"
-    val encodedHmppsId = URLEncoder.encode(hmppsId, StandardCharsets.UTF_8)
-    val path = "/v1/persons/$encodedHmppsId/person-responsible-officer"
+    val hmppsId = "11111A"
+    val path = "/v1/persons/$hmppsId/person-responsible-officer"
     val mockMvc = IntegrationAPIMockMvc(springMockMvc)
+    val filters = null
 
     describe("GET $path") {
       beforeTest {
         Mockito.reset(getPrisonOffenderManagerForPersonService)
         Mockito.reset(getCommunityOffenderManagerForPersonService)
-        whenever(getPrisonOffenderManagerForPersonService.execute(hmppsId)).thenReturn(
+        whenever(getPrisonOffenderManagerForPersonService.execute(hmppsId, filters)).thenReturn(
           Response(
             PrisonOffenderManager(
               forename = "Paul",
@@ -55,7 +53,7 @@ internal class PersonResponsibleOfficerControllerTest(
           ),
         )
 
-        whenever(getCommunityOffenderManagerForPersonService.execute(hmppsId)).thenReturn(
+        whenever(getCommunityOffenderManagerForPersonService.execute(hmppsId, filters)).thenReturn(
           Response(
             CommunityOffenderManager(
               name = PersonResponsibleOfficerName("Helen", surname = "Miller"),
@@ -82,7 +80,7 @@ internal class PersonResponsibleOfficerControllerTest(
 
       it("gets the person responsible officer for a person with the matching ID") {
         mockMvc.performAuthorised(path)
-        verify(getCommunityOffenderManagerForPersonService, VerificationModeFactory.times(1)).execute(hmppsId)
+        verify(getCommunityOffenderManagerForPersonService, VerificationModeFactory.times(1)).execute(hmppsId, filters)
       }
 
       it("logs audit") {

src/test/kotlin/uk/gov/justice/digital/hmpps/hmppsintegrationapi/integration/person/PersonResponsibleOfficerIntegrationTest.kt

@@ -8,8 +8,26 @@ import uk.gov.justice.digital.hmpps.hmppsintegrationapi.integration.IntegrationT
 class PersonResponsibleOfficerIntegrationTest : IntegrationTestBase() {
   @Test
   fun `returns needs for a person`() {
-    callApi("$basePath/$pnc/person-responsible-officer")
+    callApi("$basePath/$nomsId/person-responsible-officer")
       .andExpect(status().isOk)
       .andExpect(content().json(getExpectedResponse("person-responsible-officer")))
   }
+
+  @Test
+  fun `adjudications returns a 400 if the hmppsId is invalid`() {
+    callApi("$basePath/$invalidNomsId/person-responsible-officer")
+      .andExpect(status().isBadRequest)
+  }
+
+  @Test
+  fun `return a 404 for person in wrong prison`() {
+    callApiWithCN("$basePath/$nomsId/person-responsible-officer", limitedPrisonsCn)
+      .andExpect(status().isNotFound)
+  }
+
+  @Test
+  fun `return a 404 when no prisons in filter`() {
+    callApiWithCN("$basePath/$nomsId/person-responsible-officer", noPrisonsCn)
+      .andExpect(status().isNotFound)
+  }
 }

src/test/kotlin/uk/gov/justice/digital/hmpps/hmppsintegrationapi/services/GetCommunityOffenderManagerForPersonServiceTest.kt

@@ -31,6 +31,7 @@ class GetCommunityOffenderManagerForPersonServiceTest(
     {
       val hmppsId = "1234/56789B"
       val deliusCrn = "X224466"
+      val filter = null
 
       val person = Person(firstName = "Sam", lastName = "Smith", identifiers = Identifiers(deliusCrn = deliusCrn))
 
@@ -40,27 +41,27 @@ class GetCommunityOffenderManagerForPersonServiceTest(
         Mockito.reset(getPersonService)
         Mockito.reset(nDeliusGateway)
 
-        whenever(getPersonService.execute(hmppsId = hmppsId)).thenReturn(Response(person))
+        whenever(getPersonService.getPersonWithPrisonFilter(hmppsId = hmppsId, filter)).thenReturn(Response(person))
         whenever(nDeliusGateway.getCommunityOffenderManagerForPerson(id = deliusCrn)).thenReturn(Response(communityOffenderManager))
       }
 
       it("performs a search according to hmpps Id") {
-        getCommunityOffenderManagerForPersonService.execute(hmppsId)
-        verify(getPersonService, VerificationModeFactory.times(1)).execute(hmppsId = hmppsId)
+        getCommunityOffenderManagerForPersonService.execute(hmppsId, filter)
+        verify(getPersonService, VerificationModeFactory.times(1)).getPersonWithPrisonFilter(hmppsId = hmppsId, filter)
       }
 
       it("Returns a community offender manager for person given a hmppsId") {
-        whenever(getPersonService.execute(hmppsId = hmppsId)).thenReturn(
+        whenever(getPersonService.getPersonWithPrisonFilter(hmppsId, filter)).thenReturn(
           Response(
             data = person,
           ),
         )
-        val result = getCommunityOffenderManagerForPersonService.execute(hmppsId)
+        val result = getCommunityOffenderManagerForPersonService.execute(hmppsId, filter)
         result.shouldBe(Response(data = communityOffenderManager))
       }
 
       it("should return a list of errors if person not found") {
-        whenever(getPersonService.execute(hmppsId = "NOT_FOUND")).thenReturn(
+        whenever(getPersonService.getPersonWithPrisonFilter(hmppsId = "NOT_FOUND", filter)).thenReturn(
           Response(
             data = null,
             errors =
@@ -72,7 +73,7 @@ class GetCommunityOffenderManagerForPersonServiceTest(
               ),
           ),
         )
-        val result = getCommunityOffenderManagerForPersonService.execute("NOT_FOUND")
+        val result = getCommunityOffenderManagerForPersonService.execute("NOT_FOUND", filter)
         result.data.shouldBe(CommunityOffenderManager())
         result.errors
           .first()

src/test/kotlin/uk/gov/justice/digital/hmpps/hmppsintegrationapi/services/GetPrisonOffenderManagerForPersonServiceTest.kt

@@ -11,6 +11,7 @@ import org.springframework.test.context.ContextConfiguration
 import org.springframework.test.context.bean.override.mockito.MockitoBean
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.gateways.ManagePOMCaseGateway
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.Identifiers
+import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.NomisNumber
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.Person
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.Prison
 import uk.gov.justice.digital.hmpps.hmppsintegrationapi.models.hmpps.PrisonOffenderManager
@@ -28,23 +29,24 @@ class GetPrisonOffenderManagerForPersonServiceTest(
   private val getPrisonOffenderManagerForPersonService: GetPrisonOffenderManagerForPersonService,
 ) : DescribeSpec(
     {
-      val hmppsId = "1234/56789B"
+      val hmppsId = "56789B"
       val nomisNumber = "Z99999ZZ"
       val person = Person(firstName = "Julianna", lastName = "Blake", identifiers = Identifiers(nomisNumber = nomisNumber))
+      val filters = null
 
       val prisonOffenderManager = PrisonOffenderManager(forename = "Paul", surname = "Smith", prison = Prison(code = "RED"))
 
       beforeEach {
         Mockito.reset(getPersonService)
         Mockito.reset(managePOMCaseGateway)
 
-        whenever(getPersonService.execute(hmppsId = hmppsId)).thenReturn(Response(person))
+        whenever(getPersonService.getNomisNumberWithPrisonFilter(hmppsId = hmppsId, filters)).thenReturn(Response(NomisNumber(nomisNumber)))
         whenever(managePOMCaseGateway.getPrimaryPOMForNomisNumber(id = nomisNumber)).thenReturn(Response(prisonOffenderManager))
       }
 
       it("performs a search according to hmpps Id") {
-        getPrisonOffenderManagerForPersonService.execute(hmppsId)
-        verify(getPersonService, VerificationModeFactory.times(1)).execute(hmppsId = hmppsId)
+        getPrisonOffenderManagerForPersonService.execute(hmppsId, filters)
+        verify(getPersonService, VerificationModeFactory.times(1)).getNomisNumberWithPrisonFilter(hmppsId = hmppsId, filters)
       }
 
       it("Returns a prison offender manager for person given a hmppsId") {
@@ -53,12 +55,12 @@ class GetPrisonOffenderManagerForPersonServiceTest(
             data = person,
           ),
         )
-        val result = getPrisonOffenderManagerForPersonService.execute(hmppsId)
+        val result = getPrisonOffenderManagerForPersonService.execute(hmppsId, filters)
         result.shouldBe(Response(data = prisonOffenderManager))
       }
 
       it("should return a list of errors if person not found") {
-        whenever(getPersonService.execute(hmppsId = "NOT_FOUND")).thenReturn(
+        whenever(getPersonService.getNomisNumberWithPrisonFilter(hmppsId = "NOT_FOUND", filters)).thenReturn(
           Response(
             data = null,
             errors =
@@ -70,7 +72,7 @@ class GetPrisonOffenderManagerForPersonServiceTest(
               ),
           ),
         )
-        val result = getPrisonOffenderManagerForPersonService.execute("NOT_FOUND")
+        val result = getPrisonOffenderManagerForPersonService.execute("NOT_FOUND", filters)
         result.data.shouldBe(PrisonOffenderManager())
         result.errors
           .first()