RA-275: forward app api functionality (#37)

* api functionality

* add client and service tests

* update test descriptions

* remove test data

* update test url

* update routes, views and tests

* reinstate service calls

* temp comment out unit test

Author: madebyzak

integration_tests/e2e/forward-swap-visiting-orders-for-pin-credit-application.cy.ts

@@ -0,0 +1,48 @@
+import TestData from '../../server/routes/testutils/testData'
+import ForwardApplicationPage from '../pages/forwardApplication/swapVisitingOrdersForPinCredit'
+import Page from '../pages/page'
+
+context('Forward Application Page', () => {
+  let page: ForwardApplicationPage
+  const { prisonerApp: application } = new TestData()
+  const {
+    id: applicationId,
+    requestedBy: { id: prisonerId },
+  } = application
+
+  const visitPage = () => {
+    cy.task('reset')
+    cy.task('stubSignIn')
+    cy.task('stubGetPrisonerApp', { prisonerId, applicationId, application })
+    cy.signIn()
+    cy.visit(`/applications/business-hub/${prisonerId}/${applicationId}/forward`)
+    page = Page.verifyOnPage(ForwardApplicationPage)
+  }
+
+  beforeEach(visitPage)
+
+  describe('Page structure', () => {
+    it('should display the correct page title', () => {
+      page.pageTitle().should('include', "Forward this application to swap VO's")
+    })
+
+    it('should display all form elements', () => {
+      page.forwardToDepartment().should('exist')
+      page.forwardingReason().should('exist')
+      page.continueButton().should('exist').and('contain.text', 'Continue')
+    })
+  })
+
+  describe('Form interactions', () => {
+    it('should allow submitting the form when a department is selected', () => {
+      page.selectForwardToDepartment('activities')
+      page.continueButton().click()
+      cy.url().should('not.include', '/forward')
+    })
+
+    it('should allow adding a forwarding reason', () => {
+      const reason = 'This application needs to be reviewed by Activities department.'
+      page.forwardingReason().type(reason).should('have.value', reason)
+    })
+  })
+})

integration_tests/pages/forwardApplication/swapVisitingOrdersForPinCredit.ts

@@ -0,0 +1,21 @@
+import Page from '../page'
+
+export default class ForwardApplicationPage extends Page {
+  constructor() {
+    super("Forward this application to swap VO's")
+  }
+
+  pageTitle = () => cy.title()
+
+  forwardToDepartment = () => cy.get('.govuk-radios')
+
+  forwardingReason = () => cy.get('#forwarding-reason')
+
+  continueButton = () => cy.get('button.govuk-button--primary')
+
+  errorSummary = () => cy.get('.govuk-error-summary')
+
+  selectForwardToDepartment = (department: string) => {
+    this.forwardToDepartment().find(`input[value="${department}"]`).check()
+  }
+}

server/data/managingPrisonerAppsClient.test.ts

@@ -20,7 +20,7 @@ describe('Managing Prisoner Apps API Client', () => {
 
   afterEach(() => nock.cleanAll())
 
-  it('should return a response from the api', async () => {
+  it('should fetch a prisoner application by prisoner and application ID', async () => {
     fakeManagingPrisonerAppApi
       .get('/v1/prisoners/prisoner-id/apps/app-id')
       .matchHeader('authorization', `Bearer ${user.token}`)
@@ -29,4 +29,15 @@ describe('Managing Prisoner Apps API Client', () => {
     const output = await client.getPrisonerApp('prisoner-id', 'app-id')
     expect(output).toEqual(prisonerApp)
   })
+
+  // Reinstate with correct api endpoint and implementation once it is available
+  // it('should successfully forward an application to a different department', async () => {
+  //   fakeManagingPrisonerAppApi
+  //     .get('/v1/')
+  //     .matchHeader('authorization', `Bearer ${user.token}`)
+  //     .reply(200, undefined)
+
+  //   const output = await client.forwardApp('prisoner-id', 'app-id', 'dept')
+  //   expect(output).toBeUndefined()
+  // })
 })

server/data/managingPrisonerAppsClient.ts

@@ -24,4 +24,17 @@ export default class ManagingPrisonerAppsApiClient {
       return null
     }
   }
+
+  async forwardApp(prisonerId: string, applicationId: string, department: string): Promise<void> {
+    try {
+      await this.restClient.put({
+        path: `/v1/`,
+      })
+    } catch (error) {
+      logger.error(
+        `Error updating department for prisonerId: ${prisonerId}, applicationId: ${applicationId}, department: ${department}`,
+        error,
+      )
+    }
+  }
 }

server/routes/applications/forwardApplicationRoutes.ts

@@ -0,0 +1,83 @@
+import { Request, Response, Router } from 'express'
+import asyncMiddleware from '../../middleware/asyncMiddleware'
+import AuditService, { Page } from '../../services/auditService'
+import ManagingPrisonerAppsService from '../../services/managingPrisonerAppsService'
+import { getApplicationType } from '../../utils/getApplicationType'
+import { validateForwardingApplication } from '../validate/validateForwardingApplication'
+
+export default function forwardApplicationRoutes({
+  auditService,
+  managingPrisonerAppsService,
+}: {
+  auditService: AuditService
+  managingPrisonerAppsService: ManagingPrisonerAppsService
+}): Router {
+  const router = Router()
+
+  router.get(
+    '/applications/:departmentName/:prisonerId/:applicationId/forward',
+    asyncMiddleware(async (req: Request, res: Response) => {
+      const { departmentName, prisonerId, applicationId } = req.params
+      const { user } = res.locals
+
+      const application = await managingPrisonerAppsService.getPrisonerApp(prisonerId, applicationId, user)
+
+      if (!application) {
+        return res.redirect(`/applications/${departmentName}/pending`)
+      }
+
+      await auditService.logPageView(Page.FORWARD_APPLICATION_PAGE, {
+        who: user.username,
+        correlationId: req.id,
+      })
+
+      const applicationType = getApplicationType(application.type)
+
+      if (!applicationType) {
+        return res.redirect(`/applications/${departmentName}/pending?error=unknown-type`)
+      }
+
+      return res.render(`pages/forward-application/${applicationType.value}`, {
+        application,
+        departmentName,
+        textareaValue: '',
+        title: "Forward this application to swap VO's",
+        errors: null,
+      })
+    }),
+  )
+
+  router.post(
+    '/applications/:departmentName/:prisonerId/:applicationId/forward',
+    asyncMiddleware(async (req: Request, res: Response) => {
+      const { departmentName, prisonerId, applicationId } = req.params
+      const { forwardToDepartment, forwardingReason } = req.body
+      const { user } = res.locals
+
+      const application = await managingPrisonerAppsService.getPrisonerApp(prisonerId, applicationId, user)
+
+      if (!application) {
+        return res.redirect(`/applications/${departmentName}/pending`)
+      }
+
+      const applicationType = getApplicationType(application.type)
+      const errors = validateForwardingApplication(forwardToDepartment, forwardingReason)
+
+      if (Object.keys(errors).length > 0) {
+        return res.render(`pages/forward-application/${applicationType.value}`, {
+          application,
+          departmentName,
+          textareaValue: forwardingReason,
+          title: "Forward this application to swap VO's",
+          errors,
+        })
+      }
+
+      await managingPrisonerAppsService.forwardApp(prisonerId, applicationId, forwardToDepartment, user)
+
+      return res.redirect(`/applications/${departmentName}/${prisonerId}/${applicationId}`)
+    }),
+  )
+
+  return router
+}

server/routes/applications/index.ts

@@ -1,13 +1,14 @@
 import { Request, Response, Router } from 'express'
 import asyncMiddleware from '../../middleware/asyncMiddleware'
 import AuditService, { Page } from '../../services/auditService'
+import ManagingPrisonerAppsService from '../../services/managingPrisonerAppsService'
+import PrisonService from '../../services/prisonService'
 import applicationTypeRoutes from './applicationTypeRoutes'
+import forwardApplicationRoutes from './forwardApplicationRoutes'
 import prisonerDetailsRoutes from './prisonerDetailsRoutes'
-import swapVosPinCreditDetailsRoutes from './swapVosPinCreditDetailsRoutes'
 import submitApplicationRoutes from './submitApplicationRoutes'
+import swapVosPinCreditDetailsRoutes from './swapVosPinCreditDetailsRoutes'
 import viewApplicationRoutes from './viewApplicationsRoutes'
-import ManagingPrisonerAppsService from '../../services/managingPrisonerAppsService'
-import PrisonService from '../../services/prisonService'
 
 export default function applicationsRoutes({
   auditService,
@@ -62,9 +63,10 @@ export default function applicationsRoutes({
   )
 
   router.use(applicationTypeRoutes({ auditService }))
+  router.use(forwardApplicationRoutes({ auditService, managingPrisonerAppsService }))
   router.use(prisonerDetailsRoutes({ auditService, prisonService }))
-  router.use(swapVosPinCreditDetailsRoutes({ auditService }))
   router.use(submitApplicationRoutes({ auditService }))
+  router.use(swapVosPinCreditDetailsRoutes({ auditService }))
   router.use(viewApplicationRoutes({ auditService, managingPrisonerAppsService }))
 
   return router

server/routes/applications/viewApplicationsRoutes.ts

@@ -1,8 +1,8 @@
 import { Request, Response, Router } from 'express'
-import { APPLICATION_TYPES } from '../../constants/applicationTypes'
 import asyncMiddleware from '../../middleware/asyncMiddleware'
 import AuditService, { Page } from '../../services/auditService'
 import ManagingPrisonerAppsService from '../../services/managingPrisonerAppsService'
+import { getApplicationType } from '../../utils/getApplicationType'
 
 export default function viewApplicationRoutes({
   auditService,
@@ -34,68 +34,27 @@ export default function viewApplicationRoutes({
       const application = await managingPrisonerAppsService.getPrisonerApp(prisonerId, applicationId, user)
 
       if (!application) {
-        res.redirect(`/applications/${departmentName}/pending`)
-        return
+        return res.redirect(`/applications/${departmentName}/pending`)
       }
 
       await auditService.logPageView(Page.VIEW_APPLICATION_PAGE, {
         who: user.username,
         correlationId: req.id,
       })
 
-      const applicationType = APPLICATION_TYPES.find(type => type.apiValue === application.type)
+      const applicationType = getApplicationType(application.type)
 
       if (!applicationType) {
-        res.redirect(`/applications/${departmentName}/pending?error=unknown-type`)
-        return
+        return res.redirect(`/applications/${departmentName}/pending?error=unknown-type`)
       }
 
-      res.render(`pages/view-application/${applicationType.value}`, {
+      return res.render(`pages/view-application/${applicationType.value}`, {
         title: applicationType.name,
         application,
         departmentName,
       })
     }),
   )
 
-  router.get(
-    '/applications/:departmentName/:prisonerId/:applicationId/forward',
-    asyncMiddleware(async (req: Request, res: Response) => {
-      const { departmentName, prisonerId, applicationId } = req.params
-      const { user } = res.locals
-
-      const application = await managingPrisonerAppsService.getPrisonerApp(prisonerId, applicationId, user)
-
-      if (!application) {
-        res.redirect(`/applications/${departmentName}/pending`)
-        return
-      }
-
-      await auditService.logPageView(Page.FORWARD_APPLICATION_PAGE, {
-        who: user.username,
-        correlationId: req.id,
-      })
-
-      const applicationType = APPLICATION_TYPES.find(type => type.apiValue === application.type)
-
-      if (!applicationType) {
-        res.redirect(`/applications/${departmentName}/pending?error=unknown-type`)
-        return
-      }
-
-      res.render(`pages/forward-application/${applicationType.value}`, {
-        application,
-        departmentName,
-      })
-    }),
-  )
-
-  router.post(
-    '/applications/:departmentName/:prisonerId/:applicationId/forward',
-    asyncMiddleware(async (req: Request, res: Response) => {
-      res.redirect(``)
-    }),
-  )
-
   return router
 }

server/routes/validate/validateForwardingApplication.test.ts

@@ -0,0 +1,43 @@
+import { validateForwardingApplication } from './validateForwardingApplication'
+
+describe('validateForwardingApplication', () => {
+  it('should return an empty object when there are no errors', () => {
+    const errors = validateForwardingApplication('Some Department', 'Reason must be 1000 characters or less')
+
+    expect(errors).toEqual({})
+  })
+
+  it('should return an error for missing forwardToDepartment', () => {
+    const errors = validateForwardingApplication('', 'Reason must be 1000 characters or less')
+
+    expect(errors).toEqual({
+      forwardToDepartment: { text: 'Choose where to send' },
+    })
+  })
+
+  it('should return an error for forwardingReason longer than 1000 characters', () => {
+    const longReason = 'A'.repeat(1001)
+    const errors = validateForwardingApplication('Some Department', longReason)
+
+    expect(errors).toEqual({
+      forwardingReason: { text: 'Reason must be 1000 characters or less' },
+    })
+  })
+
+  it('should return both errors for missing forwardToDepartment and long forwardingReason', () => {
+    const longReason = 'A'.repeat(1001)
+    const errors = validateForwardingApplication('', longReason)
+
+    expect(errors).toEqual({
+      forwardToDepartment: { text: 'Choose where to send' },
+      forwardingReason: { text: 'Reason must be 1000 characters or less' },
+    })
+  })
+
+  it('should return no errors if forwardingReason is exactly 1000 characters', () => {
+    const validReason = 'A'.repeat(1000)
+    const errors = validateForwardingApplication('Some Department', validReason)
+
+    expect(errors).toEqual({})
+  })
+})

server/routes/validate/validateForwardingApplication.ts

@@ -0,0 +1,14 @@
+// eslint-disable-next-line import/prefer-default-export
+export const validateForwardingApplication = (forwardToDepartment: string, forwardingReason: string) => {
+  const errors: Record<string, { text: string }> = {}
+
+  if (!forwardToDepartment) {
+    errors.forwardToDepartment = { text: 'Choose where to send' }
+  }
+
+  if (forwardingReason && forwardingReason.length > 1000) {
+    errors.forwardingReason = { text: 'Reason must be 1000 characters or less' }
+  }
+
+  return errors
+}

server/services/managingPrisonerAppsService.test.ts

@@ -3,13 +3,14 @@ import TestData from '../routes/testutils/testData'
 import ManagingPrisonerAppsService from './managingPrisonerAppsService'
 
 const getPrisonerApp = jest.fn()
+const forwardApp = jest.fn()
 
 const testData = new TestData()
 
 jest.mock('../data/hmppsAuthClient')
 jest.mock('../data/managingPrisonerAppsClient', () => {
   return jest.fn().mockImplementation(() => {
-    return { getPrisonerApp }
+    return { getPrisonerApp, forwardApp }
   })
 })
 
@@ -37,4 +38,13 @@ describe('Managing Prisoner Apps Service', () => {
       expect(getPrisonerApp).toHaveBeenCalledWith('prisoner-id', 'application-id')
     })
   })
+
+  describe('forwardApp', () => {
+    it('should call the client and fetch the prisoner application', async () => {
+      const result = await service.forwardApp('prisoner-id', 'application-id', 'dept', user)
+
+      expect(result).toBeUndefined()
+      expect(forwardApp).toHaveBeenCalledWith('prisoner-id', 'application-id', 'dept')
+    })
+  })
 })