Add warning text to view licence page

app/presenters/licences/view-licence.presenter.js

@@ -15,22 +15,30 @@ const { formatLongDate } = require('../base.presenter.js')
  * @returns {Object} The data formatted for the view template
  */
 function go (licence) {
-  const { expiredDate, id, licenceRef, region, startDate } = licence
+  const { expiredDate, id, lapsedDate, licenceRef, region, revokedDate, startDate } = licence
+  const warning = _generateWarningMessage(expiredDate, lapsedDate, revokedDate)
 
   return {
     id,
     endDate: _endDate(expiredDate),
     licenceRef,
     region: region.displayName,
-    startDate: formatLongDate(startDate)
+    startDate: formatLongDate(startDate),
+    warning
   }
 }
 
-/**
- * Formats the expired date of the licence as the end date for the view
- *
- * @module ViewLicencePresenter
- */
+function _compareEndDates (firstEndDate, secondEndDate) {
+  if (firstEndDate.date.getTime() === secondEndDate.date.getTime()) {
+    if (firstEndDate.name === 'revoked') return firstEndDate
+    if (secondEndDate.name === 'revoked') return secondEndDate
+    if (firstEndDate.name === 'lapsed') return firstEndDate
+  } else if (firstEndDate.date < secondEndDate.date) {
+    return firstEndDate
+  }
+  return secondEndDate
+}
+
 function _endDate (expiredDate) {
   if (!expiredDate || expiredDate < Date.now()) {
     return null
@@ -39,6 +47,48 @@ function _endDate (expiredDate) {
   return formatLongDate(expiredDate)
 }
 
+function _generateWarningMessage (expiredDate, lapsedDate, revokedDate) {
+  const endDates = []
+
+  if (lapsedDate) {
+    endDates.push({
+      name: 'lapsed',
+      message: `This licence lapsed on ${formatLongDate(lapsedDate)}`,
+      date: lapsedDate
+    })
+  }
+
+  if (expiredDate) {
+    endDates.push({
+      name: 'expired',
+      message: `This licence expired on ${formatLongDate(expiredDate)}`,
+      date: expiredDate
+    })
+  }
+
+  if (revokedDate) {
+    endDates.push({
+      name: 'revoked',
+      message: `This licence was revoked on ${formatLongDate(revokedDate)}`,
+      date: revokedDate
+    })
+  }
+
+  if (endDates.length === 0) {
+    return null
+  }
+
+  if (endDates.length === 1) {
+    return endDates[0].message
+  }
+
+  const earliestPriorityEndDate = endDates.reduce((result, endDate) => {
+    return _compareEndDates(result, endDate)
+  })
+
+  return earliestPriorityEndDate.message
+}
+
 module.exports = {
   go
 }

app/views/licences/view.njk

@@ -1,6 +1,7 @@
 {% extends 'layout.njk' %}
 {% from "govuk/components/back-link/macro.njk" import govukBackLink %}
 {% from "govuk/components/tabs/macro.njk" import govukTabs %}
+{% from "govuk/components/warning-text/macro.njk" import govukWarningText %}
 
 {% block breadcrumbs %}
   {{
@@ -31,7 +32,13 @@
 {% endset %}
 
 {% block content %}
-  <h1 class="govuk-heading-l">Licence Number {{ licenceRef }}</h1>
+  {% if warning %}
+    {{ govukWarningText({
+      text: warning,
+      iconFallbackText: "Warning"
+    }) }}
+  {% endif %}
+  <h1 class="govuk-heading-l">Licence number {{ licenceRef }}</h1>
 
   {{ govukTabs({
     items: [

test/services/licences/view-licence.service.test.js

@@ -23,42 +23,257 @@ describe('View Licence service', () => {
   })
 
   describe('when a licence with a matching ID exists', () => {
-    describe('and it has an expired date', () => {
+    describe('and it does not have an expired, lapsed, or revoke date', () => {
       beforeEach(() => {
         fetchLicenceResult = _licenceData()
-        fetchLicenceResult.expiredDate = new Date('2033-03-07')
         Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
       })
 
       it('will return the data and format it for use in the licence summary page', async () => {
         const result = await ViewLicenceService.go(testId)
 
-        expect(result).to.equal({
-          id: testId,
-          licenceRef: '01/130/R01',
-          region: 'South West',
-          startDate: '7 March 2013',
-          endDate: '7 March 2033'
-        })
+        expect(result.warning).to.equal(null)
       })
     })
 
-    describe('and it does not have an expired date', () => {
+    describe('and it has an expired date, revoked date and lapsed date all in the past on the same day', () => {
       beforeEach(() => {
         fetchLicenceResult = _licenceData()
+        fetchLicenceResult.expiredDate = new Date('2023-03-07')
+        fetchLicenceResult.lapsedDate = new Date('2023-03-07')
+        fetchLicenceResult.revokedDate = new Date('2023-03-07')
         Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
       })
 
       it('will return the data and format it for use in the licence summary page', async () => {
         const result = await ViewLicenceService.go(testId)
 
-        expect(result).to.equal({
-          id: testId,
-          licenceRef: '01/130/R01',
-          region: 'South West',
-          startDate: '7 March 2013',
-          endDate: null
-        })
+        expect(result.warning).to.equal('This licence was revoked on 7 March 2023')
+      })
+    })
+
+    describe('and it has no expired date but revoked and lapsed dates are in the past on the same day', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.lapsedDate = new Date('2023-03-07')
+        fetchLicenceResult.revokedDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence was revoked on 7 March 2023')
+      })
+    })
+
+    describe('and it has no lapsed date but expired and revoked dates are in the past on the same day', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.expiredDate = new Date('2023-03-07')
+        fetchLicenceResult.revokedDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence was revoked on 7 March 2023')
+      })
+    })
+
+    describe('and it has no revoked date but expired and lapsed dates are in the past on the same day', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.expiredDate = new Date('2023-03-07')
+        fetchLicenceResult.lapsedDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence lapsed on 7 March 2023')
+      })
+    })
+
+    describe('and it only has an expired date', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.expiredDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence expired on 7 March 2023')
+      })
+    })
+
+    describe('and it only has a lapsed date', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.lapsedDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence lapsed on 7 March 2023')
+      })
+    })
+
+    describe('and it only has a revoked date', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.revokedDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence was revoked on 7 March 2023')
+      })
+    })
+
+    describe('and it has an expired and revoked date with expired being earlier', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.revokedDate = new Date('2023-03-07')
+        fetchLicenceResult.expiredDate = new Date('2023-02-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence expired on 7 February 2023')
+      })
+    })
+
+    describe('and it has an expired and lapsed date with expired being earlier', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.expiredDate = new Date('2023-02-07')
+        fetchLicenceResult.lapsedDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence expired on 7 February 2023')
+      })
+    })
+
+    describe('and it has an expired and lapsed date with lapsed being earlier', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.expiredDate = new Date('2023-03-07')
+        fetchLicenceResult.lapsedDate = new Date('2023-02-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence lapsed on 7 February 2023')
+      })
+    })
+
+    describe('and it has an expired and revoked date with revoked being earlier', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.expiredDate = new Date('2023-03-07')
+        fetchLicenceResult.revokedDate = new Date('2023-02-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence was revoked on 7 February 2023')
+      })
+    })
+
+    describe('and it has a revoked and lapsed date with lapsed being earlier', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.lapsedDate = new Date('2023-02-07')
+        fetchLicenceResult.revokedDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence lapsed on 7 February 2023')
+      })
+    })
+
+    describe('and it has a revoked and lapsed date with revoked being earlier', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.revokedDate = new Date('2023-02-07')
+        fetchLicenceResult.lapsedDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence was revoked on 7 February 2023')
+      })
+    })
+
+    describe('and it has a revoked, expired and lapsed date with revoked being earlier', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.revokedDate = new Date('2023-02-07')
+        fetchLicenceResult.lapsedDate = new Date('2023-03-07')
+        fetchLicenceResult.expiredDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence was revoked on 7 February 2023')
+      })
+    })
+
+    describe('and it has a revoked, expired and lapsed date with expired being earlier', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.revokedDate = new Date('2023-03-07')
+        fetchLicenceResult.lapsedDate = new Date('2023-03-07')
+        fetchLicenceResult.expiredDate = new Date('2023-02-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence expired on 7 February 2023')
+      })
+    })
+
+    describe('and it has a revoked, expired and lapsed date with lapsed being earlier', () => {
+      beforeEach(() => {
+        fetchLicenceResult = _licenceData()
+        fetchLicenceResult.revokedDate = new Date('2023-03-07')
+        fetchLicenceResult.lapsedDate = new Date('2023-02-07')
+        fetchLicenceResult.expiredDate = new Date('2023-03-07')
+        Sinon.stub(FetchLicenceService, 'go').resolves(fetchLicenceResult)
+      })
+
+      it('will return the data and format it for use in the licence summary page', async () => {
+        const result = await ViewLicenceService.go(testId)
+
+        expect(result.warning).to.equal('This licence lapsed on 7 February 2023')
       })
     })
   })