@defra-fish/sales-api-service 1.49.0-rc.4 → 1.49.0-rc.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/sales-api-service",
-  "version": "1.49.0-rc.4",
+  "version": "1.49.0-rc.6",
   "description": "Rod Licensing Sales API",
   "type": "module",
   "engines": {
@@ -35,9 +35,9 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@defra-fish/business-rules-lib": "1.49.0-rc.4",
-    "@defra-fish/connectors-lib": "1.49.0-rc.4",
-    "@defra-fish/dynamics-lib": "1.49.0-rc.4",
+    "@defra-fish/business-rules-lib": "1.49.0-rc.6",
+    "@defra-fish/connectors-lib": "1.49.0-rc.6",
+    "@defra-fish/dynamics-lib": "1.49.0-rc.6",
     "@hapi/boom": "^9.1.2",
     "@hapi/hapi": "^20.1.3",
     "@hapi/inert": "^6.0.3",
@@ -52,5 +52,5 @@
     "moment-timezone": "^0.5.34",
     "uuid": "^8.3.2"
   },
-  "gitHead": "5c9d0205887751b34c54c9e28d86c09ae16183ca"
+  "gitHead": "fc3df7fb041ef8127454aee7c535b85f2e04114a"
 }

package/src/schema/validators/validators.js

@@ -130,9 +130,7 @@ const validatePermissionConcession = async (permission, transaction) => {
   if (
     concessionsRequiredForPermit.length &&
     !hasConcessionProofs &&
-    transaction.dataSource !== 'Post Office Sales' &&
-    transaction.dataSource !== 'DDE File' &&
-    transaction.dataSource !== 'Postal Order Sales'
+    !['Post Office Sales', 'DDE File', 'Postal Order Sales'].includes(transaction.dataSource)
   ) {
     throw new Error(`The permit '${permission.permitId}' requires proof of concession however none were supplied`)
   } else if (!concessionsRequiredForPermit.length && hasConcessionProofs) {

package/src/server/routes/__tests__/__snapshots__/renewals.spec.js.snap

@@ -453,3 +453,90 @@ Object {
   },
 }
 `;
+
+exports[`permissionRenewalData should call preparePermissionDataForRenewal with the expected data 1`] = `
+[MockFunction] {
+  "calls": Array [
+    Array [
+      Object {
+        "concessions": Array [
+          Object {
+            "id": "d0ece997-ef65-e611-80dc-c4346bad4004",
+            "name": "Senior",
+          },
+        ],
+        "dataSource": Object {
+          "description": "Web Sales",
+          "id": 910400003,
+          "label": "Web Sales",
+        },
+        "endDate": "2020-12-13T23:59:59Z",
+        "id": "347a9083-361e-ea11-a810-000d3a25c5d6",
+        "issueDate": "2019-12-13T09:00:00Z",
+        "licensee": Object {
+          "birthDate": "1946-01-01",
+          "country": Object {
+            "description": "GB-ENG",
+            "id": 910400195,
+            "label": "England",
+          },
+          "email": "fester@tester.com",
+          "firstName": "Fester",
+          "id": "1329a866-d175-ea11-a811-000d3a64905b",
+          "lastName": "Tester",
+          "locality": "Testville",
+          "mobilePhone": "01234 567890",
+          "organisation": "Test Organisation",
+          "postalFulfilment": true,
+          "postcode": "AB12 3CD",
+          "preferredMethodOfConfirmation": Object {
+            "description": "Email",
+            "id": 910400000,
+            "label": "Email",
+          },
+          "premises": "1",
+          "street": "Tester Avenue",
+          "town": "Tersterton",
+        },
+        "permit": Object {
+          "availableFrom": "2017-03-31T23:00:00Z",
+          "availableTo": "2021-03-31T22:59:00Z",
+          "cost": 6,
+          "description": "Coarse 1 day 2 Rod Licence (Senior)",
+          "durationDesignator": Object {
+            "description": "D",
+            "id": 910400000,
+            "label": "Day(s)",
+          },
+          "durationMagnitude": 1,
+          "id": "9f1b34a0-0c66-e611-80dc-c4346bad0190",
+          "isCounterSales": true,
+          "isForFulfilment": false,
+          "isRecurringPaymentSupported": false,
+          "itemId": "42290",
+          "numberOfRods": 2,
+          "permitSubtype": Object {
+            "description": "C",
+            "id": 910400001,
+            "label": "Trout and coarse",
+          },
+          "permitType": Object {
+            "description": "Rod Fishing Licence",
+            "id": 910400000,
+            "label": "Rod Fishing Licence",
+          },
+        },
+        "referenceNumber": "00000000-2WC3FDR-CD379B",
+        "stagingId": "71ad9a25-2a03-406b-a0e3-f4ff37799374",
+        "startDate": "2019-12-14T00:00:00Z",
+      },
+    ],
+  ],
+  "results": Array [
+    Object {
+      "type": "return",
+      "value": undefined,
+    },
+  ],
+}
+`;

package/src/server/routes/__tests__/renewals.spec.js

@@ -16,6 +16,7 @@ jest.mock('../../../services/renewals/renewals.service.js', () => ({
 
 jest.mock('@defra-fish/dynamics-lib', () => ({
   ...jest.requireActual('@defra-fish/dynamics-lib'),
+  concessionsByIds: jest.fn(),
   permissionForFullReferenceNumber: jest.fn(),
   executeQuery: jest.fn()
 }))
@@ -32,16 +33,25 @@ const permissionForFullReferenceNumberMock = () => ({
   entity: MOCK_EXISTING_PERMISSION_ENTITY,
   expanded: {
     licensee: { entity: MOCK_EXISTING_CONTACT_ENTITY, expanded: {} },
-    concessionProofs: [{ entity: MOCK_CONCESSION_PROOF_ENTITY, expanded: { concession: { entity: MOCK_CONCESSION } } }],
+    concessionProofs: [{ entity: MOCK_CONCESSION_PROOF_ENTITY }],
     permit: { entity: MOCK_1DAY_SENIOR_PERMIT_ENTITY, expanded: {} }
   }
 })
 
+const concessionMock = () => ({
+  expanded: {
+    concession: {
+      entity: MOCK_CONCESSION
+    }
+  }
+})
+
 describe('permissionRenewalData', () => {
   beforeEach(jest.clearAllMocks)
 
   it('should call permissionForFullReferenceNumber with referenceNumber', async () => {
     executeQuery.mockResolvedValueOnce([permissionForFullReferenceNumberMock()])
+    executeQuery.mockResolvedValueOnce([concessionMock()])
 
     const referenceNumber = 'REFERENCE123'
     const request = getMockRequest(referenceNumber)
@@ -53,22 +63,27 @@ describe('permissionRenewalData', () => {
   })
 
   it('should call preparePermissionDataForRenewal with the expected data', async () => {
+    executeQuery.mockResolvedValueOnce([permissionForFullReferenceNumberMock()])
+    executeQuery.mockResolvedValueOnce([concessionMock()])
+
+    await permissionRenewalData[0].options.handler(getMockRequest(), getMockResponseToolkit())
+
+    expect(preparePermissionDataForRenewal).toMatchSnapshot()
+  })
+
+  it('should set concessions to an empty array if concessions is empty', async () => {
     const permissionMock = permissionForFullReferenceNumberMock()
+    permissionMock.expanded.concessionProofs = []
     executeQuery.mockResolvedValueOnce([permissionMock])
 
     await permissionRenewalData[0].options.handler(getMockRequest(), getMockResponseToolkit())
 
-    const expectedData = {
-      ...permissionMock.entity.toJSON(),
-      licensee: permissionMock.expanded.licensee.entity.toJSON(),
-      concessions: [],
-      permit: permissionMock.expanded.permit.entity.toJSON()
-    }
-    expect(preparePermissionDataForRenewal).toHaveBeenCalledWith(expectedData)
+    expect(preparePermissionDataForRenewal.mock.calls[0][0].concessions).toEqual([])
   })
 
   it('should return continue response', async () => {
     executeQuery.mockResolvedValueOnce([permissionForFullReferenceNumberMock()])
+    executeQuery.mockResolvedValueOnce([concessionMock()])
     const request = getMockRequest({})
     const responseToolkit = getMockResponseToolkit()
 

package/src/server/routes/renewals.js

@@ -2,7 +2,7 @@ import Boom from '@hapi/boom'
 import { preparePermissionDataForRenewal } from '../../services/renewals/renewals.service.js'
 import { permissionRenewalDataRequestParamsSchema, permissionRenewalDataResponseSchema } from '../../schema/renewals.schema.js'
 import db from 'debug'
-import { permissionForFullReferenceNumber, executeQuery } from '@defra-fish/dynamics-lib'
+import { concessionsByIds, permissionForFullReferenceNumber, executeQuery } from '@defra-fish/dynamics-lib'
 const debug = db('sales:permission-renewal-data')
 
 const executeWithErrorLog = async query => {
@@ -14,6 +14,14 @@ const executeWithErrorLog = async query => {
   }
 }
 
+const getConcessions = async permission => {
+  if (permission.expanded.concessionProofs.length) {
+    const concessionProofs = await executeWithErrorLog(concessionsByIds(permission.expanded.concessionProofs.map(cp => cp.entity.id)))
+    return concessionProofs.map(cp => cp.expanded.concession.entity.toJSON())
+  }
+  return []
+}
+
 export default [
   {
     method: 'GET',
@@ -23,11 +31,12 @@ export default [
         const results = await executeWithErrorLog(permissionForFullReferenceNumber(request.params.referenceNumber))
 
         if (results.length === 1) {
-          const permissionData = preparePermissionDataForRenewal({
-            ...results[0].entity.toJSON(),
-            licensee: results[0].expanded.licensee.entity.toJSON(),
-            concessions: [],
-            permit: results[0].expanded.permit.entity.toJSON()
+          const [permission] = results
+          const permissionData = await preparePermissionDataForRenewal({
+            ...permission.entity.toJSON(),
+            licensee: permission.expanded.licensee.entity.toJSON(),
+            concessions: await getConcessions(permission),
+            permit: permission.expanded.permit.entity.toJSON()
           })
           return h.response(permissionData)
         } else if (results.length === 0) {

package/src/services/__tests__/concession.service.spec.js

@@ -0,0 +1,315 @@
+import * as concessionService from '../concession.service.js'
+import { CONCESSION, CONCESSION_PROOF } from '../constants.js'
+import { getReferenceDataForEntity, getReferenceDataForEntityAndId } from '../reference-data.service.js'
+
+jest.mock('@defra-fish/connectors-lib')
+jest.mock('../reference-data.service.js')
+
+getReferenceDataForEntity.mockImplementation(() => [
+  {
+    id: 'aaa-111-bbb-222',
+    name: CONCESSION.JUNIOR
+  },
+  {
+    id: 'ccc-333-ddd-444',
+    name: CONCESSION.SENIOR
+  },
+  {
+    id: 'eee-555-fff-666',
+    name: CONCESSION.DISABLED
+  }
+])
+
+getReferenceDataForEntityAndId.mockImplementation((_e, id) => {
+  if (id === 'aaa-111-bbb-222') {
+    return {
+      id,
+      name: CONCESSION.JUNIOR
+    }
+  }
+  if (id === 'ccc-333-ddd-444') {
+    return {
+      id,
+      name: CONCESSION.SENIOR
+    }
+  }
+  if (id === 'eee-555-fff-666') {
+    return {
+      id,
+      name: CONCESSION.DISABLED
+    }
+  }
+  throw Error('Unrecognised concession id')
+})
+
+const getMockPermission = () => ({})
+
+const getJuniorConcession = () => ({
+  id: 'aaa-111-bbb-222',
+  name: CONCESSION.JUNIOR,
+  proof: {
+    type: CONCESSION_PROOF.none
+  }
+})
+
+const getSeniorConcession = () => ({
+  id: 'ccc-333-ddd-444',
+  name: CONCESSION.SENIOR,
+  proof: {
+    type: CONCESSION_PROOF.none
+  }
+})
+
+const getDisabledBlueBadgeConcession = () => ({
+  id: 'eee-555-fff-666',
+  name: CONCESSION.DISABLED,
+  proof: {
+    type: CONCESSION_PROOF.blueBadge,
+    referenceNumber: 'blue-badge-123'
+  }
+})
+
+const getDisabledNiConcession = () => ({
+  id: 'eee-555-fff-666',
+  name: CONCESSION.DISABLED,
+  proof: {
+    type: CONCESSION_PROOF.NI,
+    referenceNumber: 'national-insurance-456'
+  }
+})
+
+describe('preparePermissionDataForRenewal', () => {
+  describe('Disabled', () => {
+    describe('addDisabled', () => {
+      it('add blue badge', async () => {
+        const permission = getMockPermission()
+        await concessionService.addDisabled(permission, CONCESSION_PROOF.blueBadge, 'bb-111')
+        expect(permission.concessions).toContainEqual(
+          expect.objectContaining({
+            id: 'eee-555-fff-666',
+            name: CONCESSION.DISABLED,
+            proof: {
+              type: CONCESSION_PROOF.blueBadge,
+              referenceNumber: 'bb-111'
+            }
+          })
+        )
+      })
+
+      it('add NI', async () => {
+        const permission = getMockPermission()
+        await concessionService.addDisabled(permission, CONCESSION_PROOF.NI, 'national-insurance-456')
+        expect(permission.concessions).toContainEqual(expect.objectContaining(getDisabledNiConcession()))
+      })
+
+      it('add blue badge to senior licence', async () => {
+        const permission = getMockPermission()
+        const seniorConcession = getSeniorConcession()
+        permission.concessions = [seniorConcession]
+        await concessionService.addDisabled(permission, CONCESSION_PROOF.blueBadge, 'blue-badge-123')
+        expect(permission.concessions).toEqual(
+          expect.arrayContaining([expect.objectContaining(getDisabledBlueBadgeConcession()), expect.objectContaining(seniorConcession)])
+        )
+      })
+
+      it('add NI to senior licence', async () => {
+        const permission = getMockPermission()
+        const seniorConcession = getSeniorConcession()
+        permission.concessions = [seniorConcession]
+        await concessionService.addDisabled(permission, CONCESSION_PROOF.NI, 'national-insurance-456')
+        expect(permission.concessions).toEqual(
+          expect.arrayContaining([expect.objectContaining(getDisabledNiConcession()), expect.objectContaining(seniorConcession)])
+        )
+      })
+    })
+
+    describe('removeDisabled', () => {
+      it.each([
+        ['blue badge', []],
+        ['blue badge and senior', [getSeniorConcession()]]
+      ])('remove disabled concession from array with %s concession(s)', async (_d, additionalConcessions) => {
+        const permission = getMockPermission()
+        const disabledConcession = getDisabledBlueBadgeConcession()
+        permission.concessions = [disabledConcession, ...additionalConcessions]
+        await concessionService.removeDisabled(permission)
+        expect(permission.concessions).toEqual(expect.not.arrayContaining([expect.objectContaining(disabledConcession)]))
+      })
+
+      it.each([
+        ['NI', []],
+        ['NI and senior', [getSeniorConcession()]]
+      ])('remove disabled concession from array with %s concession(s)', async (_d, additionalConcessions) => {
+        const permission = getMockPermission()
+        const disabledConcession = getDisabledNiConcession()
+        permission.concessions = [disabledConcession, ...additionalConcessions]
+        await concessionService.removeDisabled(permission)
+        expect(permission.concessions).toEqual(expect.not.arrayContaining([expect.objectContaining(disabledConcession)]))
+      })
+
+      it.each([
+        ['senior', 'blue badge', getSeniorConcession(), getDisabledBlueBadgeConcession()],
+        ['junior', 'blue badge', getJuniorConcession(), getDisabledBlueBadgeConcession()],
+        ['senior', 'NI', getSeniorConcession(), getDisabledNiConcession()],
+        ['junior', 'NI', getJuniorConcession(), getDisabledNiConcession()]
+      ])('leaves remaining %s concession when removing a disabled %s concession', async (_cd, _dcd, concession, disabledConcession) => {
+        const permission = getMockPermission()
+        permission.concessions = [disabledConcession, concession]
+        await concessionService.removeDisabled(permission)
+        expect(permission.concessions).toEqual(expect.arrayContaining([expect.objectContaining(concession)]))
+      })
+    })
+
+    describe('hasDisabled', () => {
+      it('returns true if have disabled blue badge', async () => {
+        const permission = getMockPermission()
+        permission.concessions = [getDisabledBlueBadgeConcession()]
+        const result = await concessionService.hasDisabled(permission)
+        expect(result).toBe(true)
+      })
+
+      it('returns true if have disabled NI', async () => {
+        const permission = getMockPermission()
+        permission.concessions = [getDisabledNiConcession()]
+        const result = await concessionService.hasDisabled(permission)
+        expect(result).toBe(true)
+      })
+
+      it('returns false if do not have disabled', async () => {
+        const permission = getMockPermission()
+        permission.concessions = []
+        const result = await concessionService.hasDisabled(permission)
+        expect(result).toBe(false)
+      })
+    })
+  })
+
+  describe('Senior', () => {
+    describe('addSenior', () => {
+      it('add concession', async () => {
+        const permission = getMockPermission()
+        await concessionService.addSenior(permission)
+        expect(permission.concessions).toContainEqual(getSeniorConcession())
+      })
+
+      it("doesn't add second senior concession if one's already present", async () => {
+        const seniorConcession = getSeniorConcession()
+        const permission = getMockPermission()
+        permission.concessions = [seniorConcession]
+        await concessionService.addSenior(permission)
+        expect(permission.concessions).toEqual([expect.objectContaining(seniorConcession)])
+      })
+
+      it('add senior to blue badge', async () => {
+        const permission = getMockPermission()
+        const disabledConcession = getDisabledNiConcession()
+        permission.concessions = [disabledConcession]
+        await concessionService.addSenior(permission)
+        expect(permission.concessions).toEqual([disabledConcession, getSeniorConcession()])
+      })
+
+      it('add senior to NI', async () => {
+        const permission = getMockPermission()
+        const disabledConcession = getDisabledBlueBadgeConcession()
+        permission.concessions = [disabledConcession]
+        await concessionService.addSenior(permission)
+        expect(permission.concessions).toEqual([disabledConcession, getSeniorConcession()])
+      })
+    })
+
+    describe('removeSenior', () => {
+      it.each([
+        ['has only a senior concession', [getSeniorConcession()], []],
+        [
+          'has senior and disabled concessions',
+          [getSeniorConcession(), getDisabledBlueBadgeConcession()],
+          [getDisabledBlueBadgeConcession()]
+        ]
+      ])('removes senior concession if permission %s', async (_desc, concessions, expectedConcessions) => {
+        const permission = getMockPermission()
+        permission.concessions = concessions
+        await concessionService.removeSenior(permission)
+        expect(permission.concessions).toEqual(expectedConcessions)
+      })
+
+      it.each([
+        ['is empty', []],
+        ['has junior concession', [getJuniorConcession()]],
+        ['has junior and disabled concession', [getJuniorConcession(), getDisabledBlueBadgeConcession()]],
+        ['has disabled concession', [getDisabledNiConcession()]]
+      ])('leaves concessions unmodified if senior concession not present and concessions %s', async (_desc, concessions) => {
+        const permission = getMockPermission()
+        permission.concessions = concessions
+        await concessionService.removeSenior(permission)
+        expect(permission.concessions).toEqual(concessions)
+      })
+    })
+
+    describe('hasSenior', () => {
+      it.each(['senior'])('is true if licensee has senior concession', async () => {
+        const permission = getMockPermission()
+        permission.concessions = [getSeniorConcession()]
+        const isSenior = await concessionService.hasSenior(permission)
+        expect(isSenior).toBe(true)
+      })
+
+      it.each([
+        ['empty array', []],
+        ['array with disabled concession', [getDisabledBlueBadgeConcession()]]
+      ])("is false if licensee doesn't have senior concession in %s", async (_d, concessions) => {
+        const permission = getMockPermission()
+        permission.concessions = concessions
+        const isSenior = await concessionService.hasSenior(permission)
+        expect(isSenior).toBe(false)
+      })
+    })
+  })
+
+  describe('Junior', () => {
+    describe('removeJunior', () => {
+      it.each([
+        ['has only a junior concession', [getJuniorConcession()], []],
+        [
+          'has junior and disabled concessions',
+          [getJuniorConcession(), getDisabledBlueBadgeConcession()],
+          [getDisabledBlueBadgeConcession()]
+        ]
+      ])('removes junior concession if concessions %s', async (_desc, concessions, expectedConcessions) => {
+        const permission = getMockPermission()
+        permission.concessions = concessions
+        await concessionService.removeJunior(permission)
+        expect(permission.concessions).toEqual(expectedConcessions)
+      })
+
+      it.each([
+        ['is empty', []],
+        ['has senior concession', [getSeniorConcession()]],
+        ['has senior and disabled concession', [getSeniorConcession(), getDisabledBlueBadgeConcession()]],
+        ['has disabled concession', [getDisabledNiConcession()]]
+      ])('leaves concessions unmodified if junior concession not present and concessions %s', async (_desc, concessions) => {
+        const permission = getMockPermission()
+        permission.concessions = concessions
+        await concessionService.removeJunior(permission)
+        expect(permission.concessions).toEqual(concessions)
+      })
+    })
+
+    describe('hasJunior', () => {
+      it('returns true if permission has a junior concession', async () => {
+        const permission = getMockPermission()
+        permission.concessions = [getJuniorConcession()]
+        const result = await concessionService.hasJunior(permission)
+        expect(result).toBe(true)
+      })
+
+      it.each([
+        ['empty array', []],
+        ['array with disabled concession', [getDisabledBlueBadgeConcession()]]
+      ])("is false if licensee doesn't have junior concession in %s", async (_d, concessions) => {
+        const permission = getMockPermission()
+        permission.concessions = concessions
+        const isJunior = await concessionService.hasJunior(permission)
+        expect(isJunior).toBe(false)
+      })
+    })
+  })
+})

package/src/services/__tests__/permit.service.spec.js

@@ -0,0 +1,131 @@
+import { findPermit } from '../permit.service.js'
+import { Permit, Concession, PermitConcession } from '@defra-fish/dynamics-lib'
+import { getReferenceDataForEntity } from '../reference-data.service.js'
+
+jest.mock('../reference-data.service.js')
+
+const getSamplePermits = () => {
+  const samplePermits = [
+    {
+      id: 'prm-111',
+      numberOfRods: 1,
+      durationMagnitude: '12',
+      durationDesignator: { description: 'M' },
+      permitSubtype: { label: 'type-1' }
+    },
+    {
+      id: 'prm-222',
+      numberOfRods: 3,
+      durationMagnitude: '12',
+      durationDesignator: { description: 'M' },
+      permitSubtype: { label: 'type-2' }
+    },
+    {
+      id: 'prm-333',
+      numberOfRods: 1,
+      durationMagnitude: '12',
+      durationDesignator: { description: 'M' },
+      permitSubtype: { label: 'type-2' }
+    },
+    {
+      id: 'prm-444',
+      numberOfRods: 1,
+      durationMagnitude: '12',
+      durationDesignator: { description: 'M' },
+      permitSubtype: { label: 'type-3' }
+    }
+  ]
+  return samplePermits.map(sp => ({
+    ...sp,
+    toJSON: function () {
+      const props = {
+        ...this
+      }
+      delete props.toJSON
+      return props
+    }
+  }))
+}
+
+const getSamplePermitConcessions = () => [{ permitId: 'prm-111', concessionId: 'con-111' }]
+
+const getSampleConcessions = () => [
+  { id: 'con-111', name: 'concession-type-1' },
+  { id: 'con-222', name: 'concession-type-2' }
+]
+
+describe('findPermit', () => {
+  beforeAll(() => {
+    getReferenceDataForEntity.mockImplementation(async entity => {
+      if (entity === Permit) {
+        return getSamplePermits()
+      }
+      if (entity === PermitConcession) {
+        return getSamplePermitConcessions()
+      }
+      if (entity === Concession) {
+        return getSampleConcessions()
+      }
+      return []
+    })
+  })
+  const getSamplePermission = overrides => ({
+    permit: {
+      numberOfRods: '1',
+      permitSubtype: {
+        label: 'type-3'
+      }
+    },
+    durationMagnitude: '12',
+    durationDesignator: { description: 'M' },
+    ...overrides
+  })
+  const getSamplePermissionWithConcession = () => ({
+    concessions: [{ name: 'concession-type-1', id: 'abc-123', proof: {} }],
+    permit: {
+      numberOfRods: '1',
+      permitSubtype: {
+        label: 'type-1'
+      }
+    }
+  })
+
+  const createExpectedPermit = ({
+    numberOfRods = 1,
+    durationMagnitude = '12',
+    durationDescription = 'M',
+    permitSubtypeLabel = 'type-3',
+    ...overrides
+  } = {}) => ({
+    numberOfRods,
+    durationMagnitude,
+    durationDesignator: { description: durationDescription },
+    permitSubtype: { label: permitSubtypeLabel },
+    ...overrides
+  })
+
+  it.each`
+    description         | expectedPermit                                                                            | permission
+    ${'concessions'}    | ${createExpectedPermit({ id: 'prm-111', permitSubtypeLabel: 'type-1' })}                  | ${getSamplePermissionWithConcession()}
+    ${'licence type'}   | ${createExpectedPermit({ id: 'prm-444', permitSubtypeLabel: 'type-3' })}                  | ${getSamplePermission()}
+    ${'number of rods'} | ${createExpectedPermit({ id: 'prm-222', numberOfRods: 3, permitSubtypeLabel: 'type-2' })} | ${getSamplePermission({ permit: { permitSubtype: { label: 'type-2' }, numberOfRods: '3' } })}
+  `('matches a permission to a permit on $description', async ({ expectedPermit, permission }) => {
+    const permit = await findPermit(permission)
+    expect(permit).toStrictEqual(expect.objectContaining(expectedPermit))
+  })
+
+  it.each([
+    ['with one element', [{ type: 'concession-type-1', id: 'con-111', proof: {} }]],
+    [
+      'with two elements, one',
+      [
+        { name: 'concession-type-1', id: 'con-111', proof: {} },
+        { type: 'concession-type-2', id: 'abc-123', proof: {} }
+      ]
+    ]
+  ])('throws an error if concessions array %s containing type rather than name', async (_d, concessions) => {
+    const perm = getSamplePermissionWithConcession()
+    perm.concessions = concessions
+    await expect(() => findPermit(perm)).rejects.toThrow("Concession should contain 'name' not 'type'")
+  })
+})

package/src/services/concession.service.js

@@ -0,0 +1,61 @@
+import { CONCESSION, CONCESSION_PROOF } from './constants.js'
+import { getReferenceDataForEntity } from './reference-data.service.js'
+import { Concession } from '@defra-fish/dynamics-lib'
+
+const getTypeConcessionId = async type => {
+  const concessions = await getReferenceDataForEntity(Concession)
+  const { id } = concessions.find(c => c.name === type)
+  return id
+}
+
+const hasConcessionType = async (permission, type) => {
+  const id = await getTypeConcessionId(type)
+  return !!permission.concessions && permission.concessions.some(c => c.id === id)
+}
+
+const removeConcessionType = async (permission, type) => {
+  if (await hasConcessionType(permission, type)) {
+    const id = await getTypeConcessionId(type)
+    permission.concessions = permission.concessions.filter(c => c.id !== id)
+  }
+}
+
+export const addDisabled = async (permission, concessionProof, referenceNumber) => {
+  await removeDisabled(permission)
+  if (!permission.concessions) {
+    permission.concessions = []
+  }
+  permission.concessions.push({
+    id: await getTypeConcessionId(CONCESSION.DISABLED),
+    name: CONCESSION.DISABLED,
+    proof: {
+      type: concessionProof,
+      referenceNumber
+    }
+  })
+}
+
+export const removeDisabled = permission => removeConcessionType(permission, CONCESSION.DISABLED)
+export const hasDisabled = permission => hasConcessionType(permission, CONCESSION.DISABLED)
+
+export const addSenior = async permission => {
+  if (!(await hasSenior(permission))) {
+    await removeJunior(permission)
+    if (!permission.concessions) {
+      permission.concessions = []
+    }
+    permission.concessions.push({
+      id: await getTypeConcessionId(CONCESSION.SENIOR),
+      name: CONCESSION.SENIOR,
+      proof: {
+        type: CONCESSION_PROOF.none
+      }
+    })
+  }
+}
+
+export const removeSenior = permission => removeConcessionType(permission, CONCESSION.SENIOR)
+export const hasSenior = permission => hasConcessionType(permission, CONCESSION.SENIOR)
+
+export const removeJunior = permission => removeConcessionType(permission, CONCESSION.JUNIOR)
+export const hasJunior = permission => hasConcessionType(permission, CONCESSION.JUNIOR)

package/src/services/constants.js

@@ -0,0 +1,13 @@
+const CONCESSION = {
+  SENIOR: 'Senior',
+  JUNIOR: 'Junior',
+  DISABLED: 'Disabled'
+}
+
+const CONCESSION_PROOF = {
+  none: 'No Proof',
+  blueBadge: 'Blue Badge',
+  NI: 'National Insurance Number'
+}
+
+export { CONCESSION, CONCESSION_PROOF }

package/src/services/permit.service.js

@@ -0,0 +1,41 @@
+import { getReferenceDataForEntity } from './reference-data.service.js'
+import { Permit, Concession, PermitConcession } from '@defra-fish/dynamics-lib'
+
+export const findPermit = async existingPermission => {
+  const licenseeConcessions = existingPermission.concessions || []
+  const permitsJoinPermitConcessions = await getPermitsJoinPermitConcessions()
+
+  if (licenseeConcessions.some(c => !c.name && !!c.type)) {
+    throw new Error("Concession should contain 'name' not 'type'")
+  }
+
+  // Filter the joined list to include every and only those concessions in licenseeConcessions
+  const filteredPermitsJoinPermitConcessions = permitsJoinPermitConcessions.filter(
+    pjpc =>
+      licenseeConcessions.map(lc => lc.name).every(t => pjpc.concessions.map(c => c.name).includes(t)) &&
+      pjpc.concessions.length === licenseeConcessions.length
+  )
+
+  // Filter by the licence length
+  const byLicenceLength = filteredPermitsJoinPermitConcessions.filter(
+    p => String(p.durationMagnitude + p.durationDesignator.description) === '12M'
+  )
+
+  // Filter by the licence (sub) type
+  const byLicenceType = byLicenceLength.filter(p => p.permitSubtype.label === existingPermission.permit.permitSubtype.label)
+
+  // Filter by the number of rods
+  const byNumberOfRods = byLicenceType.filter(r => String(r.numberOfRods) === String(existingPermission.permit.numberOfRods))
+
+  return byNumberOfRods[0]
+}
+
+const getPermitsJoinPermitConcessions = async () => {
+  const permits = await getReferenceDataForEntity(Permit)
+  const permitConcessions = await getReferenceDataForEntity(PermitConcession)
+  const concessions = await getReferenceDataForEntity(Concession)
+  return permits.map(p => ({
+    ...p.toJSON(),
+    concessions: permitConcessions.filter(pc => pc.permitId === p.id).map(pc => concessions.find(c => c.id === pc.concessionId))
+  }))
+}

package/src/services/renewals/__tests__/renewals.service.spec.js

@@ -1,5 +1,30 @@
 import moment from 'moment'
 import { preparePermissionDataForRenewal } from '../renewals.service.js'
+import { findPermit } from '../../permit.service.js'
+import { getReferenceDataForEntity } from '../../reference-data.service.js'
+import { CONCESSION, CONCESSION_PROOF } from '../../constants.js'
+
+jest.mock('@defra-fish/connectors-lib')
+jest.mock('../../reference-data.service.js')
+
+getReferenceDataForEntity.mockResolvedValue([
+  {
+    id: '3230c68f-ef65-e611-80dc-c4346bad4004',
+    name: 'Junior'
+  },
+  {
+    id: 'd0ece997-ef65-e611-80dc-c4346bad4004',
+    name: 'Senior'
+  },
+  {
+    id: 'd1ece997-ef65-e611-80dc-c4346bad4004',
+    name: 'Disabled'
+  }
+])
+
+jest.mock('../../permit.service.js', () => ({
+  findPermit: jest.fn(() => ({ id: '123456' }))
+}))
 
 describe('preparePermissionDataForRenewal', () => {
   const existingPermission = overrides => ({
@@ -37,9 +62,18 @@ describe('preparePermissionDataForRenewal', () => {
       },
       numberOfRods: 1
     },
+    concessions: [],
     ...overrides
   })
 
+  const existingSeniorPermission = () =>
+    existingPermission({
+      licensee: {
+        ...existingPermission().licensee,
+        birthDate: '1958-01-01'
+      }
+    })
+
   it('should assign the correct data to the base permission', async () => {
     const expectedData = {
       isRenewal: true,
@@ -49,7 +83,7 @@ describe('preparePermissionDataForRenewal', () => {
       isLicenceForYou: true,
       permitId: '123456'
     }
-    expect(preparePermissionDataForRenewal(existingPermission())).toEqual(expect.objectContaining(expectedData))
+    expect(await preparePermissionDataForRenewal(existingPermission())).toEqual(expect.objectContaining(expectedData))
   })
 
   it('should copy the relevant licensee data', async () => {
@@ -67,20 +101,23 @@ describe('preparePermissionDataForRenewal', () => {
       preferredMethodOfConfirmation: 'Text',
       preferredMethodOfReminder: 'Letter'
     }
-    expect(preparePermissionDataForRenewal(existingPermission()).licensee).toEqual(expect.objectContaining(expectedData))
+    const permission = await preparePermissionDataForRenewal(existingPermission())
+    expect(permission.licensee).toEqual(expect.objectContaining(expectedData))
   })
 
   it('should not assign shortTermPreferredMethodOfConfirmation to the licensee', async () => {
-    const licenseeData = preparePermissionDataForRenewal(existingPermission()).licensee
-    expect(licenseeData.shortTermPreferredMethodOfConfirmation).toBeUndefined()
+    const permission = await preparePermissionDataForRenewal(existingPermission())
+    expect(permission.licensee.shortTermPreferredMethodOfConfirmation).toBeUndefined()
   })
 
   it('should remove null values from the licensee object', async () => {
-    expect(preparePermissionDataForRenewal(existingPermission()).licensee).toEqual(expect.not.objectContaining({ mobilePhone: null }))
+    const permission = await preparePermissionDataForRenewal(existingPermission())
+    expect(permission.licensee).toEqual(expect.not.objectContaining({ mobilePhone: null }))
   })
 
   it('should keep false values on the licensee object', async () => {
-    expect(preparePermissionDataForRenewal(existingPermission()).licensee).toEqual(expect.objectContaining({ postalFulfilment: false }))
+    const permission = await preparePermissionDataForRenewal(existingPermission())
+    expect(permission.licensee).toEqual(expect.objectContaining({ postalFulfilment: false }))
   })
 
   describe('when the original permission has expired', () => {
@@ -93,7 +130,7 @@ describe('preparePermissionDataForRenewal', () => {
         licenceStartTime: 0,
         renewedEndDate: endDate.toISOString()
       }
-      expect(preparePermissionDataForRenewal(existingPermission({ endDate }))).toEqual(expect.objectContaining(expectedData))
+      expect(await preparePermissionDataForRenewal(existingPermission({ endDate }))).toEqual(expect.objectContaining(expectedData))
     })
   })
 
@@ -107,7 +144,61 @@ describe('preparePermissionDataForRenewal', () => {
         licenceStartTime: endDate.hours(),
         renewedEndDate: endDate.toISOString()
       }
-      expect(preparePermissionDataForRenewal(existingPermission({ endDate }))).toEqual(expect.objectContaining(expectedData))
+      expect(await preparePermissionDataForRenewal(existingPermission({ endDate }))).toEqual(expect.objectContaining(expectedData))
+    })
+  })
+
+  describe('prepareConcessionsData', () => {
+    it('should add senior concession if the licensee is senior', async () => {
+      const samplePermission = existingSeniorPermission()
+      const ppd = await preparePermissionDataForRenewal(samplePermission)
+      const senior = { name: 'Senior', id: 'd0ece997-ef65-e611-80dc-c4346bad4004', proof: { type: 'No Proof' } }
+      expect(ppd.concessions[0]).toEqual(senior)
+    })
+
+    it("doesn't add senior concession if the licensee is not senior", async () => {
+      const permission = await preparePermissionDataForRenewal(existingPermission())
+      expect(permission.concessions).toEqual([])
+    })
+
+    it('should remove noLicenceRequired from licensee', async () => {
+      const permission = existingPermission()
+      permission.licensee.noLicenceRequired = true
+      const preparedPermission = await preparePermissionDataForRenewal(existingPermission())
+      expect(preparedPermission.licensee.noLicenceRequired).toBeUndefined()
+    })
+
+    it.each([
+      ['adult', existingPermission()],
+      ['senior', existingSeniorPermission()]
+    ])('should leave disabled concession unmodified on %s permission', async (_d, permission) => {
+      const disabledConcession = {
+        id: 'eee-555-fff-666',
+        name: CONCESSION.DISABLED,
+        proof: {
+          type: CONCESSION_PROOF.blueBadge,
+          referenceNumber: 'blue-badge-123'
+        }
+      }
+      permission.concessions = [disabledConcession]
+
+      const preparedPermission = await preparePermissionDataForRenewal(permission)
+      expect(preparedPermission.concessions).toEqual(expect.arrayContaining([expect.objectContaining(disabledConcession)]))
+    })
+  })
+
+  describe('preparePermit', () => {
+    it('permitId should match the return of findPermit.id', async () => {
+      const mockPermit = {
+        id: '101010',
+        permitSubtype: {
+          label: 'Salmon and sea trout'
+        },
+        numberOfRods: 1
+      }
+      findPermit.mockResolvedValueOnce(mockPermit)
+      const permission = await preparePermissionDataForRenewal(existingPermission())
+      expect(permission.permitId).toEqual(mockPermit.id)
     })
   })
 })

package/src/services/renewals/renewals.service.js

@@ -1,5 +1,7 @@
-import { SERVICE_LOCAL_TIME } from '@defra-fish/business-rules-lib'
+import { isSenior, SERVICE_LOCAL_TIME } from '@defra-fish/business-rules-lib'
 import moment from 'moment-timezone'
+import { addSenior } from '../concession.service.js'
+import { findPermit } from '../permit.service.js'
 
 // Replicated from GAFL - need to decide whether to move
 const cacheDateFormat = 'YYYY-MM-DD'
@@ -8,12 +10,17 @@ const licenceToStart = {
   ANOTHER_DATE: 'another-date'
 }
 
-export const preparePermissionDataForRenewal = existingPermission => ({
-  ...prepareBasePermissionData(existingPermission),
-  ...prepareDateData(existingPermission),
-  licensee: prepareLicenseeData(existingPermission),
-  permitId: preparePermitId(existingPermission)
-})
+export const preparePermissionDataForRenewal = async existingPermission => {
+  const dateData = prepareDateData(existingPermission)
+  const concessions = await prepareConcessionsData(existingPermission, dateData)
+  return {
+    ...prepareBasePermissionData(existingPermission),
+    ...dateData,
+    licensee: prepareLicenseeData(existingPermission),
+    concessions,
+    permitId: await preparePermit(existingPermission)
+  }
+}
 
 const prepareBasePermissionData = existingPermission => ({
   isRenewal: true,
@@ -83,4 +90,20 @@ const dateDataIfNotExpired = endDateMoment => {
   }
 }
 
-const preparePermitId = existingPermission => existingPermission.permit.id
+const preparePermit = async existingPermission => {
+  const permit = await findPermit(existingPermission)
+  return permit.id
+}
+
+const prepareConcessionsData = async (existingPermission, dateData) => {
+  delete existingPermission.licensee.noLicenceRequired
+  const ageAtLicenceStartDate = moment(dateData.licenceStartDate)
+    .add(1, 'year')
+    .diff(moment(existingPermission.licensee.birthDate), 'years')
+
+  if (isSenior(ageAtLicenceStartDate)) {
+    await addSenior(existingPermission)
+  }
+
+  return existingPermission.concessions
+}