Feature-requirements-for-returns-view-page

app/controllers/return-requirements.controller.js

@@ -43,6 +43,7 @@ const SubmitReturnsCycleService = require('../services/return-requirements/submi
 const SubmitSetupService = require('../services/return-requirements/setup/submit-setup.service.js')
 const SubmitSiteDescriptionService = require('../services/return-requirements/submit-site-description.service.js')
 const SubmitStartDateService = require('../services/return-requirements/submit-start-date.service.js')
+const ViewService = require('../services/return-requirements/view.service.js')
 
 async function abstractionPeriod (request, h) {
   const { requirementIndex, sessionId } = request.params
@@ -494,6 +495,15 @@ async function submitStartDate (request, h) {
   return h.redirect(`/system/return-requirements/${sessionId}/no-returns-required`)
 }
 
+async function view (request, h) {
+  const { returnVersionId } = request.params
+  const pageData = await ViewService.go(returnVersionId)
+
+  return h.view('return-requirements/view.njk', {
+    ...pageData
+  })
+}
+
 module.exports = {
   abstractionPeriod,
   add,
@@ -533,5 +543,6 @@ module.exports = {
   submitReturnsCycle,
   submitSetup,
   submitSiteDescription,
-  submitStartDate
+  submitStartDate,
+  view
 }

app/lib/general.lib.js

@@ -152,6 +152,36 @@ function generateAbstractionPointDetail (pointDetail) {
   return abstractionPoint
 }
 
+/**
+ * Generate a string that represents an abstraction point based on the new data (obs change this in PR)
+ *
+ */
+function generatePointDetail (point) {
+  let abstractionPoint = null
+
+  if (point.ngr4) {
+    const point1 = point.ngr1
+    const point2 = point.ngr2
+    const point3 = point.ngr3
+    const point4 = point.ngr4
+
+    abstractionPoint = `Within the area formed by the straight lines running between National Grid References ${point1} ${point2} ${point3} and ${point4}`
+  } else if (point.ngr2) {
+    const point1 = point.ngr1
+    const point2 = point.ngr2
+
+    abstractionPoint = `Between National Grid References ${point1} and ${point2}`
+  } else {
+    const point1 = point.ngr1
+
+    abstractionPoint = `At National Grid Reference ${point1}`
+  }
+
+  abstractionPoint += point.description !== undefined ? ` (${point.description})` : ''
+
+  return abstractionPoint
+}
+
 /**
  * Generate a Universally Unique Identifier (UUID)
  *
@@ -295,6 +325,7 @@ module.exports = {
   determineCurrentFinancialYear,
   flashNotification,
   generateAbstractionPointDetail,
+  generatePointDetail,
   generateUUID,
   periodsOverlap,
   timestampForPostgres,

app/presenters/licences/set-up.presenter.js

@@ -175,7 +175,7 @@ function _returnVersions (returnVersions = [{}]) {
     return {
       action: [{
         text: 'View',
-        link: ''
+        link: `/system/return-requirements/${returnVersion.id}/view`
       }],
       endDate: returnVersion.endDate ? formatLongDate(returnVersion.endDate) : '',
       reason: returnVersion.reason ? returnRequirementReasons[returnVersion.reason] : '',

app/presenters/return-requirements/view.presenter.js

@@ -0,0 +1,139 @@
+'use strict'
+
+/**
+ * Formats return requirements data for the `/return-requirements/{sessionId}/view` page
+ * @module ViewPresenter
+ */
+
+const { formatAbstractionDate } = require('../base.presenter.js')
+const { formatLongDate } = require('../base.presenter.js')
+const { generatePointDetail } = require('../../lib/general.lib.js')
+const { returnRequirementReasons, returnRequirementFrequencies } = require('../../lib/static-lookups.lib.js')
+
+/**
+ * Formats requirements for returns data for the `/return-requirements/{sessionId}/view` page
+ *
+ * @param {ReturnVersionModel[]} requirementsForReturns - The return version inc licence and requirements
+ *
+ * @returns {Object} returns requirement data needed by the view template
+ */
+
+function go (requirementsForReturns) {
+  const { returnRequirements, licence, reason, startDate, status, notes } = requirementsForReturns
+
+  return {
+    additionalSubmissionOptions: {
+      multipleUpload: requirementsForReturns.multipleUpload === true ? 'Yes' : 'No'
+    },
+    licenceId: licence.id,
+    licenceRef: licence.licenceRef,
+    notes,
+    pageTitle: `Check the requirements for returns for ${licence.$licenceHolder()}`,
+    reason: returnRequirementReasons[reason] || '',
+    requirements: _requirements(returnRequirements),
+    startDate: formatLongDate(startDate),
+    status: _status(status)
+  }
+}
+
+function _abstractionPeriod (requirement) {
+  const {
+    abstractionPeriodStartDay,
+    abstractionPeriodStartMonth,
+    abstractionPeriodEndDay,
+    abstractionPeriodEndMonth
+  } = requirement
+
+  const startDate = formatAbstractionDate(abstractionPeriodStartDay, abstractionPeriodStartMonth)
+  const endDate = formatAbstractionDate(abstractionPeriodEndDay, abstractionPeriodEndMonth)
+
+  return `From ${startDate} to ${endDate}`
+}
+
+function _agreementsExceptions (returnRequirement) {
+  const agreementsExceptions = _buildAgreementExceptions(returnRequirement)
+
+  if (agreementsExceptions.length === 1) {
+    return agreementsExceptions[0]
+  }
+
+  if (agreementsExceptions.length === 2) {
+    return agreementsExceptions.join(' and ')
+  }
+
+  return agreementsExceptions.slice(0, agreementsExceptions.length - 1)
+    .join(', ') + ', and ' + agreementsExceptions[agreementsExceptions.length - 1]
+}
+
+function _buildAgreementExceptions (returnRequirement) {
+  const { fiftySixException, gravityFill, reabstraction, twoPartTariff } = returnRequirement
+  const agreementsExceptions = []
+
+  if (gravityFill) {
+    agreementsExceptions.push('Gravity fill')
+  }
+
+  if (reabstraction) {
+    agreementsExceptions.push('Transfer re-abstraction scheme')
+  }
+
+  if (twoPartTariff) {
+    agreementsExceptions.push('Two-part tariff')
+  }
+
+  if (fiftySixException) {
+    agreementsExceptions.push('56 returns exception')
+  }
+
+  if (agreementsExceptions.length === 0) {
+    agreementsExceptions.push('None')
+  }
+
+  return agreementsExceptions
+}
+
+function _mapRequirement (requirement) {
+  return {
+    abstractionPeriod: _abstractionPeriod(requirement),
+    agreementsExceptions: _agreementsExceptions(requirement),
+    frequencyCollected: returnRequirementFrequencies[requirement.collectionFrequency],
+    frequencyReported: returnRequirementFrequencies[requirement.reportingFrequency],
+    points: _points(requirement.points),
+    purposes: _purposes(requirement.purposes),
+    returnsCycle: requirement.summer === true ? 'Summer' : 'Winter and all year',
+    siteDescription: requirement.siteDescription,
+    returnReference: requirement.legacyId,
+    title: requirement.siteDescription
+  }
+}
+
+function _purposes (returnRequirementPurposes) {
+  return returnRequirementPurposes.map((returnRequirementPurpose) => {
+    return returnRequirementPurpose.purposeDetails.description
+  })
+}
+
+function _points (returnRequirementPoints) {
+  return returnRequirementPoints.map((returnRequirementPoint) => {
+    return generatePointDetail(returnRequirementPoint)
+  })
+}
+
+function _requirements (requirements) {
+  return requirements.map((requirement) => {
+    return _mapRequirement(requirement)
+  })
+}
+
+function _status (status) {
+  const statuses = {
+    current: 'approved',
+    superseded: 'replaced'
+  }
+
+  return statuses[status]
+}
+
+module.exports = {
+  go
+}

app/routes/return-requirement.routes.js

@@ -470,6 +470,18 @@ const routes = [
         }
       }
     }
+  },
+  {
+    method: 'GET',
+    path: '/return-requirements/{returnVersionId}/view',
+    handler: ReturnRequirementsController.view,
+    options: {
+      auth: {
+        access: {
+          scope: ['billing']
+        }
+      }
+    }
   }
 ]
 

app/services/return-requirements/fetch-requirements-for-returns.service.js

@@ -0,0 +1,85 @@
+'use strict'
+
+/**
+ * Fetches requirements for returns by the return version id
+ * @module FetchRequirementsForReturnsService
+ */
+
+const ReturnVersionModel = require('../../models/return-version.model.js')
+
+/**
+ * Fetches requirements for returns by the return version id
+ *
+ * Includes the licence
+ *
+ * Formats the requirements
+ *
+ * @param {string} returnVersionId - The UUID of the selected return version to get requirements for
+ *
+ * @returns {Promise<Object>} The return version and its linked return requirements, plus their points and purposes
+ */
+async function go (returnVersionId) {
+  const returnVersion = await _fetch(returnVersionId)
+
+  return returnVersion
+}
+
+async function _fetch (returnVersionId) {
+  return ReturnVersionModel.query()
+    .findById(returnVersionId)
+    .select([
+      'id',
+      'multiple_upload',
+      'notes',
+      'reason',
+      'startDate',
+      'status'
+    ])
+    .withGraphFetched('licence')
+    .modifyGraph('licence', (builder) => {
+      builder.select([
+        'id',
+        'licenceRef'
+      ]).modify('licenceHolder')
+    })
+    .withGraphFetched('returnRequirements')
+    .modifyGraph('returnRequirements', (builder) => {
+      builder.select([
+        'abstractionPeriodEndDay',
+        'abstractionPeriodEndMonth',
+        'abstractionPeriodStartDay',
+        'abstractionPeriodStartMonth',
+        'collectionFrequency',
+        'fiftySixException',
+        'gravityFill',
+        'id',
+        'legacyId',
+        'reabstraction',
+        'reportingFrequency',
+        'siteDescription',
+        'summer',
+        'twoPartTariff'
+      ])
+    })
+    .withGraphFetched('returnRequirements.[returnRequirementPoints as points]')
+    .modifyGraph('returnRequirements.[returnRequirementPoints as points]', (builder) => {
+      builder.select([
+        'description',
+        'ngr1',
+        'ngr2',
+        'ngr3',
+        'ngr4'
+      ])
+    })
+    .withGraphFetched('returnRequirements.[returnRequirementPurposes as purposes.[purpose as purposeDetails]]')
+    .modifyGraph('returnRequirements.[returnRequirementPurposes as purposes]', (builder) => {
+      builder.select(['id'])
+    })
+    .modifyGraph('returnRequirements.[returnRequirementPurposes as purposes.[purpose as purposeDetails]]', (builder) => {
+      builder.select(['description'])
+    })
+}
+
+module.exports = {
+  go
+}

app/services/return-requirements/view.service.js

@@ -0,0 +1,31 @@
+'use strict'
+
+/**
+ * Orchestrates fetching and presenting the data for `/return-requirements/{sessionId}/view` page
+ * @module ViewService
+ */
+
+const FetchRequirementsForReturnsService = require('./fetch-requirements-for-returns.service.js')
+const ViewPresenter = require('../../presenters/return-requirements/view.presenter.js')
+
+/**
+ * Orchestrates fetching and presenting the data for `/return-requirements/{sessionId}/view` page
+ *
+ * @param {string} returnVersionId - The UUID for return requirement version
+ *
+ * @returns {Promise<Object>} page data needed by the view template
+ */
+async function go (returnVersionId) {
+  const requirementsForReturns = await FetchRequirementsForReturnsService.go(returnVersionId)
+
+  const data = ViewPresenter.go(requirementsForReturns)
+
+  return {
+    activeNavBar: 'search',
+    ...data
+  }
+}
+
+module.exports = {
+  go
+}