Allow new details in clinic sessions to be edited (#249)

* Allow new details in clinic sessions to be edited

This commit also updates create-data to generate valid vaccination periods and staffing levels for the clinic sessions we create.

* Add the clinic location to session title

Author: malross

app/controllers/session.js

@@ -30,7 +30,10 @@ import {
   today
 } from '../utils/date.js'
 import { getResults, getPagination } from '../utils/pagination.js'
-import { getSessionYearGroups } from '../utils/session.js'
+import {
+  getSessionYearGroups,
+  getVaccinationPeriodsSummary
+} from '../utils/session.js'
 import { formatYearGroup } from '../utils/string.js'
 
 export const sessionController = {
@@ -490,14 +493,49 @@ export const sessionController = {
     const { session_id } = request.params
     const { data } = request.session
 
-    // Setup wizard if not already setup
+    // Copy the saved session to the wizard context, if not already there
     let session = Session.findOne(session_id, data.wizard)
     if (!session) {
+      // NB: response.locals.session was set in read()
       session = Session.create(response.locals.session, data.wizard)
+      response.locals.session.vaccinationPeriods.forEach(
+        (vaccinationPeriod) => {
+          ClinicVaccinationPeriod.create(vaccinationPeriod, data.wizard)
+        }
+      )
+    }
+
+    // Set up the transaction metadata that controls how some clinic values are entered
+    if (session.type === SessionType.Clinic) {
+      const vaccinatorCounts = new Set(
+        session.vaccination_period_ids.map(
+          (period_id) =>
+            ClinicVaccinationPeriod.findOne(period_id, data.wizard)
+              ?.vaccinatorCount
+        )
+      )
+      const variableVaccinatorCounts = vaccinatorCounts.size > 1
+      data.transaction = {
+        hasVariableVaccinatorCounts: variableVaccinatorCounts ? 'true' : 'false'
+      }
+      if (!variableVaccinatorCounts) {
+        data.transaction.consistentVaccinatorCount = vaccinatorCounts
+          .values()
+          .next()
+          .value.toString()
+      }
     }
 
     response.locals.session = new Session(session, data)
 
+    // Generate summary info for the edit page
+    response.locals.vaccinationPeriodsSummary = getVaccinationPeriodsSummary(
+      session.vaccination_period_ids.map((period_id) =>
+        ClinicVaccinationPeriod.findOne(period_id, data.wizard)
+      ),
+      session.appointmentLength
+    )
+
     // Show back link to session page
     response.locals.back = session.uri
 
@@ -517,7 +555,20 @@ export const sessionController = {
         data
       )
 
+      // Update any clinic vaccination periods
+      if (session.type === SessionType.Clinic) {
+        session.vaccination_period_ids.forEach((period_id) => {
+          const vaccinationPeriod = ClinicVaccinationPeriod.findOne(
+            period_id,
+            data.wizard
+          )
+          ClinicVaccinationPeriod.update(period_id, vaccinationPeriod, data)
+        })
+      }
+
       // Clean up session data
+      delete data.vaccinationPeriods
+      delete data.transaction
       delete data.session
       delete data.wizard
 
@@ -613,6 +664,15 @@ export const sessionController = {
         } else {
           response.locals.clinics = Clinic.findAll(data)
         }
+
+        // Generate summary info for the check-answers page
+        if (vaccinationPeriods) {
+          response.locals.vaccinationPeriodsSummary =
+            getVaccinationPeriodsSummary(
+              vaccinationPeriods,
+              session.appointmentLength
+            )
+        }
       }
 
       if (session.type === SessionType.School) {

app/data.js

@@ -2,6 +2,7 @@ import vaccines from './datasets/vaccines.js'
 import batches from '../.data/batches.json' with { type: 'json' }
 import clinicAppointments from '../.data/clinic-appointments.json' with { type: 'json' }
 import clinicBookings from '../.data/clinic-bookings.json' with { type: 'json' }
+import clinicVaccinationPeriods from '../.data/clinic-vaccination-periods.json' with { type: 'json' }
 import clinics from '../.data/clinics.json' with { type: 'json' }
 import instructions from '../.data/instructions.json' with { type: 'json' }
 import moves from '../.data/moves.json' with { type: 'json' }
@@ -34,6 +35,7 @@ const data = {
   batches,
   clinicAppointments,
   clinicBookings,
+  clinicVaccinationPeriods,
   clinics,
   counts: {},
   defaultBatches: {},

app/generators/clinic-vaccination-periods.js

@@ -0,0 +1,63 @@
+import { fakerEN_GB as faker } from '@faker-js/faker'
+import { addMinutes } from 'date-fns'
+
+import { ClinicVaccinationPeriod } from '../models.js'
+
+/**
+ * Generate one or more time periods during which vaccinations will be administered at a clinic
+ *
+ * @param {string} session_id - session ID for the clinic whose vaccination periods we're creating
+ * @param {Date} sessionDate - the date on which the clinic's running
+ * @returns {Array<ClinicVaccinationPeriod>} - one or more vaccination periods
+ */
+export function generateClinicVaccinationPeriods(session_id, sessionDate) {
+  const periodCount = faker.helpers.weightedArrayElement([
+    { value: 1, weight: 70 },
+    { value: 2, weight: 30 }
+  ])
+
+  const vaccinationPeriodLengths = Array.from({ length: periodCount }).map(
+    () => {
+      return faker.number.int({ min: 60, max: 180, multipleOf: 30 })
+    }
+  )
+  const breakLength =
+    periodCount > 1 ? faker.number.int({ min: 15, max: 60, multipleOf: 15 }) : 0
+  const totalSessionLength =
+    vaccinationPeriodLengths.reduce((total, next) => total + next, 0) +
+    breakLength
+
+  const earliestSessionStartTime = new Date(sessionDate.setUTCHours(9, 0)) // 9am
+  const latestSessionFinishTime = new Date(sessionDate.setUTCHours(20, 0)) // 8pm
+  const sessionWindow = Math.floor(
+    (latestSessionFinishTime.getTime() - earliestSessionStartTime.getTime()) /
+      1000 /
+      60
+  )
+  const startOffset = faker.number.int({
+    min: 0,
+    max: sessionWindow - totalSessionLength,
+    multipleOf: 15
+  })
+  const sessionStartTime = addMinutes(earliestSessionStartTime, startOffset)
+
+  let nextPeriodStartTime = sessionStartTime
+  return vaccinationPeriodLengths.map((periodLength) => {
+    const vaccinationPeriod = new ClinicVaccinationPeriod({
+      session_id,
+      startAt: nextPeriodStartTime,
+      endAt: addMinutes(nextPeriodStartTime, periodLength),
+      vaccinatorCount: faker.helpers.weightedArrayElement([
+        { value: 2, weight: 5 },
+        { value: 3, weight: 85 },
+        { value: 4, weight: 10 }
+      ])
+    })
+    nextPeriodStartTime = addMinutes(
+      nextPeriodStartTime,
+      periodLength + breakLength
+    )
+
+    return vaccinationPeriod
+  })
+}

app/generators/session.js

@@ -1,6 +1,6 @@
 import { fakerEN_GB as faker } from '@faker-js/faker'
 
-import { SessionType, TeamDefaults } from '../enums.js'
+import { SessionPresetName, SessionType, TeamDefaults } from '../enums.js'
 import { Session } from '../models.js'
 import { addDays, getTermDates, removeDays, setMidday } from '../utils/date.js'
 import { getSessionYearGroups } from '../utils/session.js'
@@ -42,14 +42,21 @@ export function generateSession(preset, academicYear, user, options) {
 
     date = setMidday(date)
 
-    // Don’t create sessions during weekends
-    if ([0, 6].includes(date.getDay())) {
-      date = removeDays(date, 2)
+    if (school_id) {
+      // Don’t create school sessions during weekends
+      if ([0, 6].includes(date.getDay())) {
+        date = removeDays(date, 2)
+      }
     }
 
     openAt = removeDays(date, TeamDefaults.SessionOpenWeeks * 7)
   }
 
+  let appointmentLength
+  if (clinic_id) {
+    appointmentLength = preset.name === SessionPresetName.Flu ? 5 : 10
+  }
+
   let yearGroups
   if (options.school_id) {
     yearGroups = getSessionYearGroups(options.school_id, [preset])
@@ -63,7 +70,11 @@ export function generateSession(preset, academicYear, user, options) {
     registration: true,
     academicYear,
     presetNames: [preset.name],
-    ...(clinic_id && { type: SessionType.Clinic, clinic_id }),
+    ...(clinic_id && {
+      type: SessionType.Clinic,
+      clinic_id,
+      appointmentLength
+    }),
     ...(school_id && { type: SessionType.School, school_id, yearGroups })
   })
 }

app/locales/en.js

@@ -2224,7 +2224,7 @@ export const en = {
       input: {
         allPeriodsLabel: 'All periods',
         singlePeriodLabel:
-          '{{startTime.hour}}:{{startTime.minute}} to {{endTime.hour}}:{{endTime.minute}}',
+          '{{startAt_.hour}}:{{startAt_.minute}} to {{endAt_.hour}}:{{endAt_.minute}}',
         suffix: 'vaccinators'
       },
       varies: {

app/models/clinic-vaccination-period.js

@@ -41,9 +41,11 @@ export class ClinicVaccinationPeriod {
    * @returns {number} - the number of whole appointments that can fitted into this period
    */
   appointmentCount(appointmentLengthInMinutes) {
-    const periodLengthInMs = Math.abs(
-      this.endAt.getTime() - this.startAt.getTime()
-    )
+    if (!this.endAt || !this.startAt) {
+      return 0
+    }
+
+    const periodLengthInMs = this.endAt.getTime() - this.startAt.getTime()
     if (periodLengthInMs <= 0) {
       return 0
     }

app/models/session.js

@@ -609,7 +609,7 @@ export class Session {
    */
   get shortName() {
     if (this.clinic) {
-      return `${this.programmeNames.titleCase} community clinic`
+      return `${this.programmeNames.titleCase} clinic at ${this.location.name}`
     }
 
     if (this.location) {

app/utils/session.js

@@ -114,3 +114,51 @@ export const getSessionYearGroups = (school_id, sessionPresets) => {
     [...programmeYearGroups].includes(yearGroup)
   )
 }
+
+/**
+ * Get various summary details for a clinic session's vaccination periods
+ *
+ * @param {Array<import('../models.js').ClinicVaccinationPeriod>} vaccinationPeriods - the vaccination periods for a given clinic session
+ * @param {number} appointmentLength - the length of a single appointment, in minutes
+ * @returns {object} - the summary details for a clinic session's vaccination period(s)
+ */
+export const getVaccinationPeriodsSummary = (
+  vaccinationPeriods,
+  appointmentLength
+) => {
+  {
+    let startAndEndTimes = ''
+    let vaccinatorCounts = ''
+    let lastVaccinatorCount = -1
+    let hasVariableVaccinatorCounts = false
+    let totalSlots = 0
+    vaccinationPeriods.forEach((vaccinationPeriod, periodIndex) => {
+      const thisPeriod = `${vaccinationPeriod.startAt_.hour}:${vaccinationPeriod.startAt_.minute} to ${vaccinationPeriod.endAt_.hour}:${vaccinationPeriod.endAt_.minute}`
+      const thisVaccinatorCount = vaccinationPeriod.vaccinatorCount || 0
+
+      startAndEndTimes += thisPeriod
+      vaccinatorCounts += `${thisVaccinatorCount} from ${thisPeriod}`
+      if (periodIndex < vaccinationPeriods.length - 1) {
+        startAndEndTimes += '<br>'
+        vaccinatorCounts += '<br>'
+      }
+
+      hasVariableVaccinatorCounts =
+        hasVariableVaccinatorCounts ||
+        (lastVaccinatorCount !== -1 &&
+          lastVaccinatorCount !== thisVaccinatorCount)
+      lastVaccinatorCount = thisVaccinatorCount
+
+      totalSlots += vaccinationPeriod.appointmentCount(appointmentLength)
+    })
+    if (!hasVariableVaccinatorCounts) {
+      vaccinatorCounts = lastVaccinatorCount.toString()
+    }
+
+    return {
+      startAndEndTimes,
+      vaccinatorCounts,
+      totalSlots
+    }
+  }
+}