@defra-fish/sales-api-service 1.58.0 → 1.59.0-rc.1

package/src/schema/__tests__/recurring-payments.schema.spec.js

@@ -0,0 +1,99 @@
+import { dueRecurringPaymentsResponseSchema } from '../recurring-payments.schema.js'
+
+jest.mock('../validators/validators.js', () => ({
+  ...jest.requireActual('../validators/validators.js'),
+  createEntityIdValidator: () => () => {} // sample data so we don't want it validated for being a real entity id
+}))
+
+const getSampleData = () => ({
+  id: 'd5549fc6-41c1-ef11-b8e8-7c1e52215dc9',
+  name: 'test',
+  status: 0,
+  nextDueDate: '2025-01-22T00:00:00.000Z',
+  cancelledDate: null,
+  cancelledReason: null,
+  endDate: '2025-12-22T23:59:59.000Z',
+  agreementId: 'c756d22b-0003-4e24-a922-009f358852bd',
+  activePermission: 'cb549fc6-41c1-ef11-b8e8-7c1e52215dc9',
+  contactId: 'bf549fc6-41c1-ef11-b8e8-7c1e52215dc9',
+  publicId: 'q/kJYJrYNt/PkVbWChugMRSSxoDEttw1ownaNzDDyEw=',
+  expanded: {
+    contact: {
+      entity: {
+        id: 'bf549fc6-41c1-ef11-b8e8-7c1e52215dc9',
+        firstName: 'Recurring',
+        lastName: 'Test',
+        birthDate: '1991-01-01',
+        email: 'recurring.test@hotmail.com',
+        mobilePhone: null,
+        organisation: null,
+        premises: '1',
+        street: 'Catharine Place',
+        locality: null,
+        town: 'Bath',
+        postcode: 'BA1 2PR'
+      }
+    },
+    activePermission: {
+      entity: {
+        id: 'cb549fc6-41c1-ef11-b8e8-7c1e52215dc9',
+        referenceNumber: '23221225-2WC3FRT-ADQFJ6',
+        issueDate: '2024-12-23T15:22:49.000Z',
+        startDate: '2024-12-23T15:52:49.000Z',
+        endDate: '2025-12-22T23:59:59.000Z',
+        stagingId: 'a544cc77-156c-40e7-9c69-02e70829341d',
+        dataSource: {
+          id: 910400003,
+          label: 'Web Sales',
+          description: 'Web Sales'
+        }
+      }
+    }
+  }
+})
+
+describe('getDueRecurringPaymentsSchema', () => {
+  it('validates expected object', async () => {
+    await expect(() => dueRecurringPaymentsResponseSchema.validateAsync(getSampleData())).not.toThrow()
+  })
+
+  it.each([
+    'id',
+    'name',
+    'status',
+    'nextDueDate',
+    'cancelledDate',
+    'cancelledReason',
+    'endDate',
+    'agreementId',
+    'activePermission',
+    'contactId',
+    'publicId'
+  ])('throws an error if %s is missing', async property => {
+    const sampleData = getSampleData()
+    delete sampleData[property]
+    expect(() => dueRecurringPaymentsResponseSchema.validateAsync(sampleData)).rejects.toThrow()
+  })
+
+  it.each([
+    ['id', 'not-a-guid'],
+    ['name', 99],
+    ['status', 'not-a-number'],
+    ['nextDueDate', 'not-a-date'],
+    ['cancelledDate', 'not-a-date'],
+    ['cancelledReason', 99],
+    ['endDate', 'not-a-date'],
+    ['agreementId', 'not-a-guid'],
+    ['activePermission', 'not-a-guid'],
+    ['contactId', 'still-not-a-guid'],
+    ['publicId', 99]
+  ])('throws an error if %s is not the correct type', async (property, value) => {
+    const sampleData = getSampleData()
+    sampleData[property] = value
+    expect(() => dueRecurringPaymentsResponseSchema.validateAsync(sampleData)).rejects.toThrow()
+  })
+
+  it('snapshot test schema', async () => {
+    expect(dueRecurringPaymentsResponseSchema).toMatchSnapshot()
+  })
+})

package/src/schema/authenticate.schema.js

@@ -5,11 +5,10 @@ import { permitSchema } from './permit.schema.js'
 import { contactResponseSchema } from './contact.schema.js'
 import { finalisedPermissionSchemaContent } from './permission.schema.js'
 
+const REFERENCE_LENGTH = 6
+
 export const authenticateRenewalRequestParamsSchema = Joi.object({
-  referenceNumber: Joi.string()
-    .min(6)
-    .required()
-    .description('The permission reference number (supports partial)')
+  referenceNumber: Joi.string().min(REFERENCE_LENGTH).required().description('The permission reference number (supports partial)')
 }).label('authenticate-renewal-request-params')
 
 export const authenticateRenewalRequestQuerySchema = Joi.object({

package/src/schema/permission.schema.js

@@ -5,25 +5,25 @@ import { optionSetOption } from './option-set.schema.js'
 import { createReferenceDataEntityValidator } from './validators/validators.js'
 import { Permit } from '@defra-fish/dynamics-lib'
 import { validation } from '@defra-fish/business-rules-lib'
-import { v4 as uuid } from 'uuid'
 
+const DATE_EXAMPLE = '2025-01-01T00:00:00.000Z'
 const issueDateSchema = Joi.string()
   .isoDate()
   .required()
   .allow(null)
   .description('An ISO8601 compatible date string defining when the permission was issued')
-  .example(new Date().toISOString())
+  .example(DATE_EXAMPLE)
 const startDateSchema = Joi.string()
   .isoDate()
   .required()
   .allow(null)
   .description('An ISO8601 compatible date string defining when the permission commences')
-  .example(new Date().toISOString())
+  .example(DATE_EXAMPLE)
 const endDateSchema = Joi.string()
   .isoDate()
   .required()
   .description('An ISO8601 compatible date string defining when the permission expires')
-  .example(new Date().toISOString())
+  .example(DATE_EXAMPLE)
 
 export const stagedPermissionSchema = Joi.object({
   permitId: Joi.string()
@@ -41,12 +41,12 @@ export const stagedPermissionSchema = Joi.object({
 }).label('staged-permission')
 
 export const finalisedPermissionSchemaContent = {
-  id: Joi.string().guid().required().example(uuid()),
+  id: Joi.string().guid().required().example('a17fc331-141b-4fc0-8549-329d6934fadb'),
   referenceNumber: validation.permission.createPermissionNumberValidator(Joi),
   issueDate: issueDateSchema,
   startDate: startDateSchema,
   endDate: endDateSchema,
-  stagingId: Joi.string().guid().required().example(uuid()),
+  stagingId: Joi.string().guid().required().example('a17fc331-141b-4fc0-8549-329d6934fadb'),
   dataSource: optionSetOption
 }
 

package/src/schema/recurring-payments.schema.js

@@ -0,0 +1,21 @@
+import Joi from 'joi'
+import { commonContactSchema } from './contact.schema.js'
+import { finalisedPermissionSchemaContent } from './permission.schema.js'
+
+export const dueRecurringPaymentsResponseSchema = Joi.object({
+  id: Joi.string().guid().required(),
+  name: Joi.string().required(),
+  status: Joi.number().required(),
+  nextDueDate: Joi.string().isoDate().required(),
+  cancelledDate: Joi.string().isoDate().allow(null).required(),
+  cancelledReason: Joi.string().allow(null).required(),
+  endDate: Joi.string().isoDate().required(),
+  agreementId: Joi.string().guid().required(),
+  activePermission: Joi.string().guid().required(),
+  contactId: Joi.string().guid().required(),
+  publicId: Joi.string().required(),
+  expanded: Joi.object({
+    contact: { entity: commonContactSchema },
+    activePermission: { entity: finalisedPermissionSchemaContent }
+  })
+})

package/src/server/routes/__tests__/authenticate-new.spec.js

@@ -1,4 +1,4 @@
-import { permissionForLicensee, executeQuery } from '@defra-fish/dynamics-lib'
+import { contactForLicenseeNoReference, executeQuery } from '@defra-fish/dynamics-lib'
 import db from 'debug'
 jest.mock('@defra-fish/dynamics-lib')
 jest.mock('debug')
@@ -10,7 +10,7 @@ describe('executeWithErrorLog', () => {
     executeQuery.mockImplementation(() => {
       throw new Error()
     })
-    permissionForLicensee.mockReturnValueOnce({ filter: 'query filter test' })
+    contactForLicenseeNoReference.mockReturnValueOnce({ filter: 'query filter test' })
     const authenticate = require('../authenticate.js').default
     const [
       {

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

@@ -1,5 +1,5 @@
 import initialiseServer from '../../server.js'
-import { executeQuery, permissionForLicensee } from '@defra-fish/dynamics-lib'
+import { contactForLicenseeNoReference, executeQuery, permissionForContacts } from '@defra-fish/dynamics-lib'
 import {
   MOCK_EXISTING_PERMISSION_ENTITY,
   MOCK_EXISTING_CONTACT_ENTITY,
@@ -10,8 +10,9 @@ import {
 
 jest.mock('@defra-fish/dynamics-lib', () => ({
   ...jest.requireActual('@defra-fish/dynamics-lib'),
-  permissionForLicensee: jest.fn(),
-  executeQuery: jest.fn()
+  contactForLicenseeNoReference: jest.fn(),
+  executeQuery: jest.fn(),
+  permissionForContacts: jest.fn()
 }))
 
 let server = null
@@ -27,6 +28,12 @@ describe('authenticate handler', () => {
 
   describe('authenticateRenewal', () => {
     it('authenticates a renewal request', async () => {
+      executeQuery.mockResolvedValueOnce([
+        {
+          entity: MOCK_EXISTING_CONTACT_ENTITY,
+          expanded: {}
+        }
+      ])
       executeQuery.mockResolvedValueOnce([
         {
           entity: MOCK_EXISTING_PERMISSION_ENTITY,
@@ -42,7 +49,6 @@ describe('authenticate handler', () => {
         method: 'GET',
         url: '/authenticate/renewal/CD379B?licenseeBirthDate=2000-01-01&licenseePostcode=AB12 3CD'
       })
-      expect(permissionForLicensee).toHaveBeenCalledWith('CD379B', '2000-01-01', 'AB12 3CD')
       expect(result.statusCode).toBe(200)
       expect(JSON.parse(result.payload)).toMatchObject({
         permission: expect.objectContaining({
@@ -61,6 +67,12 @@ describe('authenticate handler', () => {
 
     describe('if no concessions are returned', () => {
       beforeEach(() => {
+        executeQuery.mockResolvedValueOnce([
+          {
+            entity: MOCK_EXISTING_CONTACT_ENTITY,
+            expanded: {}
+          }
+        ])
         executeQuery.mockResolvedValueOnce([
           {
             entity: MOCK_EXISTING_PERMISSION_ENTITY,
@@ -73,12 +85,20 @@ describe('authenticate handler', () => {
         ])
       })
 
-      it('should call permissionForLicensee with the licence number, dob and postcode for a renewal request, ', async () => {
+      it('should call contactForLicenseeNoReference with dob and postcode for a renewal request', async () => {
+        await server.inject({
+          method: 'GET',
+          url: '/authenticate/renewal/CD379B?licenseeBirthDate=2000-01-01&licenseePostcode=AB12 3CD'
+        })
+        expect(contactForLicenseeNoReference).toHaveBeenCalledWith('2000-01-01', 'AB12 3CD')
+      })
+
+      it('should call permissionForContacts with contact ids from contactForLicenseeNoReference', async () => {
         await server.inject({
           method: 'GET',
           url: '/authenticate/renewal/CD379B?licenseeBirthDate=2000-01-01&licenseePostcode=AB12 3CD'
         })
-        expect(permissionForLicensee).toHaveBeenCalledWith('CD379B', '2000-01-01', 'AB12 3CD')
+        expect(permissionForContacts).toHaveBeenCalledWith([MOCK_EXISTING_CONTACT_ENTITY.id])
       })
 
       it('returns 200 from a renewal request', async () => {
@@ -105,7 +125,13 @@ describe('authenticate handler', () => {
     })
 
     it('throws 500 errors if more than one result was found for the query', async () => {
-      executeQuery.mockResolvedValueOnce([{}, {}])
+      executeQuery.mockResolvedValueOnce([
+        {
+          entity: MOCK_EXISTING_CONTACT_ENTITY,
+          expanded: {}
+        }
+      ])
+      executeQuery.mockResolvedValueOnce([{ entity: { referenceNumber: 'CD379B' } }, { entity: { referenceNumber: 'CD379B' } }])
       const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn())
       const result = await server.inject({
         method: 'GET',
@@ -121,6 +147,26 @@ describe('authenticate handler', () => {
     })
 
     it('throws 401 errors if the renewal could not be authenticated', async () => {
+      executeQuery.mockResolvedValueOnce([
+        {
+          entity: MOCK_EXISTING_CONTACT_ENTITY,
+          expanded: {}
+        }
+      ])
+      executeQuery.mockResolvedValueOnce([])
+      const result = await server.inject({
+        method: 'GET',
+        url: '/authenticate/renewal/CD379B?licenseeBirthDate=2000-01-01&licenseePostcode=AB12 3CD'
+      })
+      expect(result.statusCode).toBe(401)
+      expect(JSON.parse(result.payload)).toMatchObject({
+        error: 'Unauthorized',
+        message: 'The licensee could not be authenticated',
+        statusCode: 401
+      })
+    })
+
+    it('throws 401 errors if no contact to be authenticated', async () => {
       executeQuery.mockResolvedValueOnce([])
       const result = await server.inject({
         method: 'GET',

package/src/server/routes/__tests__/recurring-payments.spec.js

@@ -1,6 +1,12 @@
 import dueRecurringPayments from '../recurring-payments.js'
 import { getRecurringPayments } from '../../../services/recurring-payments.service.js'
 
+const [
+  {
+    options: { handler: drpHandler }
+  }
+] = dueRecurringPayments
+
 jest.mock('../../../services/recurring-payments.service.js', () => ({
   getRecurringPayments: jest.fn()
 }))
@@ -19,13 +25,13 @@ describe('recurring payments', () => {
   it('handler should return continue response', async () => {
     const request = getMockRequest({})
     const responseToolkit = getMockResponseToolkit()
-    expect(await dueRecurringPayments[0].handler(request, responseToolkit)).toEqual(responseToolkit.continue)
+    expect(await drpHandler(request, responseToolkit)).toEqual(responseToolkit.continue)
   })
 
   it('should call getRecurringPayments with date', async () => {
     const date = Symbol('date')
     const request = getMockRequest({ date })
-    await dueRecurringPayments[0].handler(request, getMockResponseToolkit())
+    await drpHandler(request, getMockResponseToolkit())
     expect(getRecurringPayments).toHaveBeenCalledWith(date)
   })
 })

package/src/server/routes/authenticate.js

@@ -5,8 +5,9 @@ import {
   authenticateRenewalResponseSchema
 } from '../../schema/authenticate.schema.js'
 import db from 'debug'
-import { permissionForLicensee, concessionsByIds, executeQuery } from '@defra-fish/dynamics-lib'
+import { permissionForContacts, concessionsByIds, executeQuery, contactForLicenseeNoReference } from '@defra-fish/dynamics-lib'
 const debug = db('sales:renewal-authentication')
+const failAuthenticate = 'The licensee could not be authenticated'
 
 const executeWithErrorLog = async query => {
   try {
@@ -24,33 +25,37 @@ export default [
     options: {
       handler: async (request, h) => {
         const { licenseeBirthDate, licenseePostcode } = request.query
-        const results = await executeWithErrorLog(
-          permissionForLicensee(request.params.referenceNumber, licenseeBirthDate, licenseePostcode)
-        )
-
-        if (results.length === 1) {
-          let concessionProofs = []
-          if (results[0].expanded.concessionProofs.length > 0) {
-            const ids = results[0].expanded.concessionProofs.map(f => f.entity.id)
-            concessionProofs = await executeWithErrorLog(concessionsByIds(ids))
+        const contacts = await executeWithErrorLog(contactForLicenseeNoReference(licenseeBirthDate, licenseePostcode))
+        if (contacts.length > 0) {
+          const contactIds = contacts.map(contact => contact.entity.id)
+          const permissions = await executeWithErrorLog(permissionForContacts(contactIds))
+          const results = permissions.filter(p => p.entity.referenceNumber.endsWith(request.params.referenceNumber))
+          if (results.length === 1) {
+            let concessionProofs = []
+            if (results[0].expanded.concessionProofs.length > 0) {
+              const ids = results[0].expanded.concessionProofs.map(f => f.entity.id)
+              concessionProofs = await executeWithErrorLog(concessionsByIds(ids))
+            }
+            return h
+              .response({
+                permission: {
+                  ...results[0].entity.toJSON(),
+                  licensee: results[0].expanded.licensee.entity.toJSON(),
+                  concessions: concessionProofs.map(c => ({
+                    id: c.expanded.concession.entity.id,
+                    proof: c.entity.toJSON()
+                  })),
+                  permit: results[0].expanded.permit.entity.toJSON()
+                }
+              })
+              .code(200)
+          } else if (results.length === 0) {
+            throw Boom.unauthorized(failAuthenticate)
+          } else {
+            throw new Error('Unable to authenticate, non-unique results for query')
           }
-          return h
-            .response({
-              permission: {
-                ...results[0].entity.toJSON(),
-                licensee: results[0].expanded.licensee.entity.toJSON(),
-                concessions: concessionProofs.map(c => ({
-                  id: c.expanded.concession.entity.id,
-                  proof: c.entity.toJSON()
-                })),
-                permit: results[0].expanded.permit.entity.toJSON()
-              }
-            })
-            .code(200)
-        } else if (results.length === 0) {
-          throw Boom.unauthorized('The licensee could not be authenticated')
         } else {
-          throw new Error('Unable to authenticate, non-unique results for query')
+          throw Boom.unauthorized(failAuthenticate)
         }
       },
       description: 'Authenticate a licensee by checking the licence number corresponds with the provided contact details',
@@ -66,7 +71,7 @@ export default [
         'hapi-swagger': {
           responses: {
             200: { description: 'The licensee was successfully authenticated', schema: authenticateRenewalResponseSchema },
-            401: { description: 'The licensee could not be authenticated' }
+            401: { description: failAuthenticate }
           },
           order: 1
         }

package/src/server/routes/recurring-payments.js

@@ -1,12 +1,25 @@
+import { dueRecurringPaymentsResponseSchema } from '../../schema/recurring-payments.schema.js'
 import { getRecurringPayments } from '../../services/recurring-payments.service.js'
 export default [
   {
     method: 'GET',
     path: '/dueRecurringPayments/{date}',
-    handler: async (request, h) => {
-      const { date } = request.params
-      const result = await getRecurringPayments(date)
-      return h.response(result)
+    options: {
+      handler: async (request, h) => {
+        const { date } = request.params
+        const result = await getRecurringPayments(date)
+        return h.response(result)
+      },
+      description: 'Retrieve recurring payments due for the specified date',
+      tags: ['api', 'recurring-payments'],
+      plugins: {
+        'hapi-swagger': {
+          responses: {
+            200: { description: 'Recurring payments due', schema: dueRecurringPaymentsResponseSchema }
+          },
+          order: 1
+        }
+      }
     }
   }
 ]