VB-3518, additional support page

server/@types/bapv.d.ts

@@ -19,6 +19,8 @@ export type BookingJourneyData = {
 
   // selected visitors for this visit
   selectedVisitors?: VisitorInfoDto[]
+
+  visitorSupport?: string
 }
 
 export type FlashData = {

server/@types/orchestration-api.d.ts

@@ -695,21 +695,21 @@ export interface components {
       visitTimeSlot: components['schemas']['SessionTimeSlotDto']
     }
     PageVisitDto: {
-      /** Format: int64 */
-      totalElements?: number
       /** Format: int32 */
       totalPages?: number
+      /** Format: int64 */
+      totalElements?: number
+      first?: boolean
+      last?: boolean
+      content?: components['schemas']['VisitDto'][]
       /** Format: int32 */
       size?: number
-      content?: components['schemas']['VisitDto'][]
       /** Format: int32 */
       number?: number
       sort?: components['schemas']['SortObject'][]
+      pageable?: components['schemas']['PageableObject']
       /** Format: int32 */
       numberOfElements?: number
-      pageable?: components['schemas']['PageableObject']
-      first?: boolean
-      last?: boolean
       empty?: boolean
     }
     PageableObject: {
@@ -920,13 +920,18 @@ export interface components {
        * @example 2020-11-01
        */
       sessionDate: string
+      /**
+       * @description sessionTemplateReference
+       * @example v9d.7ed.7u
+       */
+      sessionTemplateReference: string
       sessionTimeSlot: components['schemas']['SessionTimeSlotDto']
       /**
        * @description Visit Restriction
        * @example OPEN
        * @enum {string}
        */
-      visitRestriction: 'OPEN' | 'CLOSED' | 'UNKNOWN'
+      visitRestriction: 'OPEN' | 'CLOSED'
     }
     GetDlqResult: {
       /** Format: int32 */
@@ -2171,7 +2176,12 @@ export interface operations {
          * @description Filter sessions by session restriction - OPEN or CLOSED, if prisoner has CLOSED it will use that
          * @example CLOSED
          */
-        sessionRestriction: 'OPEN' | 'CLOSED'
+        sessionRestriction?: 'OPEN' | 'CLOSED'
+        /**
+         * @description List of visitors who require visit sessions
+         * @example 4729510,4729220
+         */
+        visitors?: number[]
       }
     }
     responses: {

server/routes/bookingJourney/index.ts

@@ -6,6 +6,8 @@ import type { Services } from '../../services'
 import SelectPrisonerController from './selectPrisonerController'
 import SelectVisitorsController from './selectVisitorsController'
 import DateAndTimeController from './selectDateAndTimeController'
+import AdditionalSupportController from './selectAdditionalSupportController'
+import MainContactController from './selectMainContactController'
 
 export default function routes(services: Services): Router {
   const router = Router()
@@ -18,6 +20,8 @@ export default function routes(services: Services): Router {
   const selectPrisonerController = new SelectPrisonerController()
   const selectVisitorsController = new SelectVisitorsController(services.bookerService, services.prisonService)
   const dateAndTimeController = new DateAndTimeController(services.bookerService)
+  const additionalSupportController = new AdditionalSupportController(services.bookerService)
+  const mainContactController = new MainContactController(services.bookerService)
 
   // TODO need session checks for each stage to validate what is in session - add middleware here to apply to all booking journey routes?
 
@@ -28,5 +32,16 @@ export default function routes(services: Services): Router {
   postWithValidation('/select-visitors', selectVisitorsController.validate(), selectVisitorsController.submit())
 
   get('/select-date-and-time', dateAndTimeController.view())
+
+  get('/select-additional-support', additionalSupportController.view())
+
+  postWithValidation(
+    '/select-additional-support',
+    additionalSupportController.validate(),
+    additionalSupportController.submit(),
+  )
+
+  get('/select-main-contact', mainContactController.view())
+
   return router
 }

server/routes/bookingJourney/selectAdditionalSupport.test.ts

@@ -0,0 +1,169 @@
+import type { Express } from 'express'
+import request from 'supertest'
+import * as cheerio from 'cheerio'
+import { SessionData } from 'express-session'
+import { FieldValidationError } from 'express-validator'
+import { appWithAllRoutes, flashProvider } from '../testutils/appSetup'
+import { createMockBookerService, createMockPrisonService } from '../../services/testutils/mocks'
+import TestData from '../testutils/testData'
+import { FlashData } from '../../@types/bapv'
+
+let app: Express
+
+const bookerService = createMockBookerService()
+const prisonService = createMockPrisonService()
+let sessionData: SessionData
+
+const url = '/book-a-visit/select-additional-support'
+
+const bookerReference = TestData.bookerReference().value
+const prisoner = TestData.prisonerInfoDto()
+const prison = TestData.prisonDto()
+const visitors = [
+  TestData.visitorInfoDto({ personId: 1, firstName: 'Visitor', lastName: 'One', dateOfBirth: '1980-02-03' }),
+  TestData.visitorInfoDto({ personId: 2, firstName: 'Visitor', lastName: 'Two', dateOfBirth: '1990-09-03' }),
+  TestData.visitorInfoDto({ personId: 3, firstName: 'Visitor', lastName: 'Three', dateOfBirth: '2024-03-01' }),
+]
+
+afterEach(() => {
+  jest.resetAllMocks()
+  jest.useRealTimers()
+})
+
+describe('Select additional support page', () => {
+  let flashData: FlashData
+
+  describe(`GET ${url}`, () => {
+    beforeEach(() => {
+      flashData = {}
+      flashProvider.mockImplementation((key: keyof FlashData) => flashData[key])
+
+      sessionData = {
+        booker: { reference: bookerReference, prisoners: [prisoner] },
+        bookingJourney: { allVisitors: visitors, selectedVisitors: visitors, prisoner, prison },
+      } as SessionData
+
+      app = appWithAllRoutes({ services: { bookerService, prisonService }, sessionData })
+    })
+
+    it('should render additional support page', () => {
+      return request(app)
+        .get(url)
+        .expect('Content-Type', /html/)
+        .expect(res => {
+          const $ = cheerio.load(res.text)
+          expect($('title').text()).toMatch(/^Any additional support needs\? -/)
+          expect($('[data-test="back-link"]').attr('href')).toBe('/')
+          expect($('h1').text()).toBe('Is additional support needed for any of the visitors?')
+
+          expect($('[data-test=prison-name]').text().trim()).toContain('Hewell (HMP)')
+
+          expect($('form[method=POST]').attr('action')).toBe('/book-a-visit/select-additional-support')
+
+          expect($('[data-test="continue-button"]').text().trim()).toBe('Continue')
+        })
+    })
+
+    it('should render validation errors', () => {
+      const validationError: FieldValidationError = {
+        type: 'field',
+        location: 'body',
+        path: 'additionalSupport',
+        value: [],
+        msg: 'Enter details of the request',
+      }
+
+      flashData = { errors: [validationError], formValues: { visitorIds: [] } }
+
+      return request(app)
+        .get(url)
+        .expect('Content-Type', /html/)
+        .expect(res => {
+          const $ = cheerio.load(res.text)
+          expect($('.govuk-error-summary a[href="#additionalSupport-error"]').text()).toBe(
+            'Enter details of the request',
+          )
+          expect($('#additionalSupport-error').text()).toContain('Enter details of the request')
+        })
+    })
+  })
+
+  describe(`POST ${url}`, () => {
+    beforeEach(() => {
+      sessionData = {
+        booker: {
+          reference: bookerReference,
+          prisoners: [prisoner],
+        },
+        bookingJourney: {
+          prisoner,
+          prison,
+          allVisitors: visitors,
+          selectedVisitors: [visitors[0], visitors[2]],
+        },
+      } as SessionData
+
+      app = appWithAllRoutes({ sessionData })
+    })
+
+    it('should should save entered additional support to session and redirect to main contact page', () => {
+      return request(app)
+        .post(url)
+        .send({ additionalSupportRequired: 'yes', additionalSupport: 'Wheelchair access' })
+        .expect(302)
+        .expect('Location', '/book-a-visit/select-main-contact')
+        .expect(() => {
+          expect(sessionData).toStrictEqual({
+            booker: {
+              reference: bookerReference,
+              prisoners: [prisoner],
+            },
+            bookingJourney: {
+              prisoner,
+              prison,
+              allVisitors: visitors,
+              selectedVisitors: [visitors[0], visitors[2]],
+              visitorSupport: 'Wheelchair access',
+            },
+          } as SessionData)
+        })
+    })
+
+    it('should set a validation error and redirect to original page when no options selected', () => {
+      const expectedFlashData: FlashData = {
+        errors: [
+          {
+            type: 'field',
+            location: 'body',
+            path: 'additionalSupportRequired',
+            value: undefined,
+            msg: 'No answer selected',
+          },
+        ],
+        formValues: { additionalSupport: '' },
+      }
+
+      return request(app)
+        .post(url)
+        .expect(302)
+        .expect('Location', url)
+        .expect(() => {
+          expect(flashProvider).toHaveBeenCalledWith('errors', expectedFlashData.errors)
+          expect(flashProvider).toHaveBeenCalledWith('formValues', expectedFlashData.formValues)
+
+          expect(sessionData).toStrictEqual({
+            booker: {
+              reference: bookerReference,
+              prisoners: [prisoner],
+            },
+            bookingJourney: {
+              prisoner,
+              prison,
+              allVisitors: visitors,
+              selectedVisitors: [visitors[0], visitors[2]],
+            },
+          } as SessionData)
+        })
+    })
+  })
+})

server/routes/bookingJourney/selectAdditionalSupportController.ts

@@ -0,0 +1,49 @@
+import type { RequestHandler } from 'express'
+import { ValidationChain, body, validationResult } from 'express-validator'
+import { BookerService } from '../../services'
+
+export default class AdditionalSupportController {
+  public constructor(private readonly bookerService: BookerService) {}
+
+  public view(): RequestHandler {
+    return async (req, res) => {
+      res.render('pages/bookingJourney/selectAdditionalSupport', {
+        errors: req.flash('errors'),
+        formValues: req.flash('formValues')?.[0] || {},
+        booker: req.session.booker,
+        bookingJourney: req.session.bookingJourney,
+      })
+    }
+  }
+
+  public submit(): RequestHandler {
+    return async (req, res) => {
+      const { bookingJourney } = req.session
+      const errors = validationResult(req)
+
+      if (!errors.isEmpty()) {
+        req.flash('errors', errors.array() as [])
+        req.flash('formValues', req.body)
+        return res.redirect(`/book-a-visit/select-additional-support`)
+      }
+
+      bookingJourney.visitorSupport = req.body.additionalSupportRequired === 'no' ? '' : req.body.additionalSupport
+
+      return res.redirect('/book-a-visit/select-main-contact')
+    }
+  }
+
+  validate(): ValidationChain[] {
+    return [
+      body('additionalSupportRequired').isIn(['yes', 'no']).withMessage('No answer selected'),
+      body('additionalSupport')
+        .trim()
+        .if(body('additionalSupportRequired').equals('yes'))
+        .notEmpty()
+        .withMessage('Enter details of the request')
+        .bail()
+        .isLength({ min: 3, max: 512 })
+        .withMessage('Please enter at least 3 and no more than 512 characters'),
+    ]
+  }
+}

server/routes/bookingJourney/selectMainContactController.ts

@@ -0,0 +1,15 @@
+import type { RequestHandler } from 'express'
+import { BookerService } from '../../services'
+
+export default class MainContactController {
+  public constructor(private readonly bookerService: BookerService) {}
+
+  public view(): RequestHandler {
+    return async (req, res) => {
+      res.render('pages/bookingJourney/selectMainContact', {
+        booker: req.session.booker,
+        bookingJourney: req.session.bookingJourney,
+      })
+    }
+  }
+}