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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/sales-api-service",
-  "version": "1.57.0-rc.4",
+  "version": "1.57.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.57.0-rc.4",
-    "@defra-fish/connectors-lib": "1.57.0-rc.4",
-    "@defra-fish/dynamics-lib": "1.57.0-rc.4",
+    "@defra-fish/business-rules-lib": "1.57.0-rc.6",
+    "@defra-fish/connectors-lib": "1.57.0-rc.6",
+    "@defra-fish/dynamics-lib": "1.57.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": "54475774a2f320e8ba0ed1e6baa624e23f14decc"
+  "gitHead": "5c21e5443b8224f43c980c6a53746c593196500b"
 }

package/src/services/__tests__/__snapshots__/recurring-payments.service.spec.js.snap

@@ -8,7 +8,7 @@ Object {
   "endDate": 2023-11-12T00:00:00.000Z,
   "name": "Test Name",
   "nextDueDate": 2023-11-02T00:00:00.000Z,
-  "publicId": "1234456",
+  "publicId": "abcdef99987",
   "status": 0,
 }
 `;

package/src/services/__tests__/recurring-payments.service.spec.js

@@ -1,5 +1,6 @@
-import { findDueRecurringPayments } from '@defra-fish/dynamics-lib'
-import { getRecurringPayments, processRecurringPayment } from '../recurring-payments.service.js'
+import { findDueRecurringPayments, Permission } from '@defra-fish/dynamics-lib'
+import { getRecurringPayments, processRecurringPayment, generateRecurringPaymentRecord } from '../recurring-payments.service.js'
+import { createHash } from 'node:crypto'
 
 jest.mock('@defra-fish/dynamics-lib', () => ({
   ...jest.requireActual('@defra-fish/dynamics-lib'),
@@ -8,6 +9,13 @@ jest.mock('@defra-fish/dynamics-lib', () => ({
   findDueRecurringPayments: jest.fn()
 }))
 
+jest.mock('node:crypto', () => ({
+  createHash: jest.fn(() => ({
+    update: () => {},
+    digest: () => 'abcdef99987'
+  }))
+}))
+
 const dynamicsLib = jest.requireMock('@defra-fish/dynamics-lib')
 
 const getMockRecurringPayment = () => ({
@@ -81,6 +89,22 @@ const getMockPermission = () => ({
 })
 
 describe('recurring payments service', () => {
+  const createSimpleSampleTransactionRecord = () => ({ payment: { recurring: true }, permissions: [{}] })
+  const createSamplePermission = overrides => {
+    const p = new Permission()
+    p.referenceNumber = 'ABC123'
+    p.issueDate = '2024-12-04T11:15:12Z'
+    p.startDate = '2024-12-04T11:45:12Z'
+    p.endDate = '2025-12-03T23:59:59.999Z'
+    p.stagingId = 'aaa-111-bbb-222'
+    p.isRenewal = false
+    p.isLicenseForYou = 1
+    for (const key in overrides) {
+      p[key] = overrides[key]
+    }
+    return p
+  }
+
   beforeEach(jest.clearAllMocks)
   describe('getRecurringPayments', () => {
     it('should equal result of findDueRecurringPayments query', async () => {
@@ -123,7 +147,6 @@ describe('recurring payments service', () => {
             cancelledReason: null,
             endDate: new Date('2023-11-12'),
             agreementId: '435678',
-            publicId: '1234456',
             status: 0
           }
         },
@@ -133,5 +156,175 @@ describe('recurring payments service', () => {
       const result = await processRecurringPayment(transactionRecord, contact)
       expect(result.recurringPayment).toMatchSnapshot()
     })
+
+    it.each(['abc-123', 'def-987'])('generates a publicId %s for the recurring payment', async samplePublicId => {
+      createHash.mockReturnValue({
+        update: () => {},
+        digest: () => samplePublicId
+      })
+      const result = await processRecurringPayment(createSimpleSampleTransactionRecord(), getMockContact())
+      expect(result.recurringPayment.publicId).toBe(samplePublicId)
+    })
+
+    it('passes the unique id of the entity to the hash.update function', async () => {
+      const update = jest.fn()
+      createHash.mockReturnValueOnce({
+        update,
+        digest: () => {}
+      })
+      const { recurringPayment } = await processRecurringPayment(createSimpleSampleTransactionRecord(), getMockContact())
+      expect(update).toHaveBeenCalledWith(recurringPayment.uniqueContentId)
+    })
+
+    it('hashes using sha256', async () => {
+      await processRecurringPayment(createSimpleSampleTransactionRecord(), getMockContact())
+      expect(createHash).toHaveBeenCalledWith('sha256')
+    })
+
+    it('uses base64 hash string', async () => {
+      const digest = jest.fn()
+      createHash.mockReturnValueOnce({
+        update: () => {},
+        digest
+      })
+      await processRecurringPayment(createSimpleSampleTransactionRecord(), getMockContact())
+      expect(digest).toHaveBeenCalledWith('base64')
+    })
+  })
+
+  describe('generateRecurringPaymentRecord', () => {
+    const createFinalisedSampleTransaction = (agreementId, permission) => ({
+      expires: 1732892402,
+      cost: 35.8,
+      isRecurringPaymentSupported: true,
+      permissions: [
+        {
+          permitId: 'permit-id-1',
+          licensee: {},
+          referenceNumber: '23211125-2WC3FBP-ABNDT8',
+          isLicenceForYou: true,
+          ...permission
+        }
+      ],
+      agreementId,
+      payment: {
+        amount: 35.8,
+        source: 'Gov Pay',
+        method: 'Debit card',
+        timestamp: '2024-11-22T15:00:45.922Z'
+      },
+      id: 'd26d646f-ed0f-4cf1-b6c1-ccfbbd611757',
+      dataSource: 'Web Sales',
+      transactionId: 'd26d646f-ed0f-4cf1-b6c1-ccfbbd611757',
+      status: { id: 'FINALISED' }
+    })
+
+    it.each([
+      [
+        'same day start - next due on issue date plus one year minus ten days',
+        'iujhy7u8ijhy7u8iuuiuu8ie89',
+        {
+          startDate: '2024-11-22T15:30:45.922Z',
+          issueDate: '2024-11-22T15:00:45.922Z',
+          endDate: '2025-11-21T23:59:59.999Z'
+        },
+        '2025-11-12T00:00:00.000Z'
+      ],
+      [
+        'next day start - next due on end date minus ten days',
+        '89iujhy7u8i87yu9iokjuij901',
+        {
+          startDate: '2024-11-23T00:00:00.000Z',
+          issueDate: '2024-11-22T15:00:45.922Z',
+          endDate: '2025-11-22T23:59:59.999Z'
+        },
+        '2025-11-12T00:00:00.000Z'
+      ],
+      [
+        'starts ten days after issue - next due on issue date plus one year',
+        '9o8u7yhui89u8i9oiu8i8u7yhu',
+        {
+          startDate: '2024-11-22T00:00:00.000Z',
+          issueDate: '2024-11-12T15:00:45.922Z',
+          endDate: '2025-11-21T23:59:59.999Z'
+        },
+        '2025-11-12T00:00:00.000Z'
+      ],
+      [
+        'starts twenty days after issue - next due on issue date plus one year',
+        '9o8u7yhui89u8i9oiu8i8u7yhu',
+        {
+          startDate: '2024-12-01T00:00:00.000Z',
+          issueDate: '2024-11-12T15:00:45.922Z',
+          endDate: '2025-01-30T23:59:59.999Z'
+        },
+        '2025-11-12T00:00:00.000Z'
+      ],
+      [
+        "issued on 29th Feb '24, starts on 30th March '24 - next due on 28th Feb '25",
+        'hy7u8ijhyu78jhyu8iu8hjiujn',
+        {
+          startDate: '2024-03-30T00:00:00.000Z',
+          issueDate: '2024-02-29T12:38:24.123Z',
+          endDate: '2025-03-29T23:59:59.999Z'
+        },
+        '2025-02-28T00:00:00.000Z'
+      ],
+      [
+        "issued on 30th March '25 at 1am, starts at 1:30am - next due on 20th March '26",
+        'jhy67uijhy67u87yhtgjui8u7j',
+        {
+          startDate: '2025-03-30T01:30:00.000Z',
+          issueDate: '2025-03-30T01:00:00.000Z',
+          endDate: '2026-03-29T23:59:59.999Z'
+        },
+        '2026-03-20T00:00:00.000Z'
+      ]
+    ])('creates record from transaction with %s', (_d, agreementId, permissionData, expectedNextDueDate) => {
+      const sampleTransaction = createFinalisedSampleTransaction(agreementId, permissionData)
+      const permission = createSamplePermission(permissionData)
+
+      const rpRecord = generateRecurringPaymentRecord(sampleTransaction, permission)
+
+      expect(rpRecord).toEqual(
+        expect.objectContaining({
+          payment: expect.objectContaining({
+            recurring: expect.objectContaining({
+              name: '',
+              nextDueDate: expectedNextDueDate,
+              cancelledDate: null,
+              cancelledReason: null,
+              endDate: permissionData.endDate,
+              agreementId,
+              status: 1
+            })
+          }),
+          permissions: expect.arrayContaining([permission])
+        })
+      )
+    })
+
+    it.each([
+      [
+        'start date is thirty one days after issue date',
+        {
+          startDate: '2024-12-14T00:00:00.000Z',
+          issueDate: '2024-11-12T15:00:45.922Z',
+          endDate: '2025-12-13T23:59:59.999Z'
+        }
+      ],
+      [
+        'start date precedes issue date',
+        {
+          startDate: '2024-11-11T00:00:00.000Z',
+          issueDate: '2024-11-12T15:00:45.922Z',
+          endDate: '2025-11-10T23:59:59.999Z'
+        }
+      ]
+    ])('throws an error for invalid dates when %s', (_d, permission) => {
+      const sampleTransaction = createFinalisedSampleTransaction('hyu78ijhyu78ijuhyu78ij9iu6', permission)
+
+      expect(() => generateRecurringPaymentRecord(sampleTransaction)).toThrow('Invalid dates provided for permission')
+    })
   })
 })

package/src/services/recurring-payments.service.js

@@ -1,22 +1,59 @@
 import { executeQuery, findDueRecurringPayments, RecurringPayment } from '@defra-fish/dynamics-lib'
+import { createHash } from 'node:crypto'
+import { ADVANCED_PURCHASE_MAX_DAYS } from '@defra-fish/business-rules-lib'
+import moment from 'moment'
 
 export const getRecurringPayments = date => executeQuery(findDueRecurringPayments(date))
 
+const getNextDueDate = (startDate, issueDate, endDate) => {
+  const mStart = moment(startDate)
+  if (mStart.isAfter(moment(issueDate)) && mStart.isSameOrBefore(moment(issueDate).add(ADVANCED_PURCHASE_MAX_DAYS, 'days'), 'day')) {
+    if (mStart.isSame(moment(issueDate), 'day')) {
+      return moment(startDate).add(1, 'year').subtract(10, 'days').startOf('day').toISOString()
+    }
+    if (mStart.isBefore(moment(issueDate).add(10, 'days'), 'day')) {
+      return moment(endDate).subtract(10, 'days').startOf('day').toISOString()
+    }
+    return moment(issueDate).add(1, 'year').startOf('day').toISOString()
+  }
+  throw new Error('Invalid dates provided for permission')
+}
+
+export const generateRecurringPaymentRecord = (transactionRecord, permission) => {
+  const [{ startDate, issueDate, endDate }] = transactionRecord.permissions
+  return {
+    payment: {
+      recurring: {
+        name: '',
+        nextDueDate: getNextDueDate(startDate, issueDate, endDate),
+        cancelledDate: null,
+        cancelledReason: null,
+        endDate,
+        agreementId: transactionRecord.agreementId,
+        status: 1
+      }
+    },
+    permissions: [permission]
+  }
+}
+
 /**
  * Process a recurring payment instruction
  * @param transactionRecord
  * @returns {Promise<{recurringPayment: RecurringPayment | null}>}
  */
 export const processRecurringPayment = async (transactionRecord, contact) => {
+  const hash = createHash('sha256')
   if (transactionRecord.payment?.recurring) {
     const recurringPayment = new RecurringPayment()
+    hash.update(recurringPayment.uniqueContentId)
     recurringPayment.name = transactionRecord.payment.recurring.name
     recurringPayment.nextDueDate = transactionRecord.payment.recurring.nextDueDate
     recurringPayment.cancelledDate = transactionRecord.payment.recurring.cancelledDate
     recurringPayment.cancelledReason = transactionRecord.payment.recurring.cancelledReason
     recurringPayment.endDate = transactionRecord.payment.recurring.endDate
     recurringPayment.agreementId = transactionRecord.payment.recurring.agreementId
-    recurringPayment.publicId = transactionRecord.payment.recurring.publicId
+    recurringPayment.publicId = hash.digest('base64')
     recurringPayment.status = transactionRecord.payment.recurring.status
     const [permission] = transactionRecord.permissions
     recurringPayment.bindToEntity(RecurringPayment.definition.relationships.activePermission, permission)

package/src/services/transactions/__tests__/process-transaction-queue.spec.js

@@ -26,6 +26,7 @@ import { TRANSACTION_STAGING_TABLE, TRANSACTION_STAGING_HISTORY_TABLE } from '..
 import AwsMock from 'aws-sdk'
 import { POCL_DATA_SOURCE, DDE_DATA_SOURCE } from '@defra-fish/business-rules-lib'
 import moment from 'moment'
+import { processRecurringPayment, generateRecurringPaymentRecord } from '../../recurring-payments.service.js'
 
 jest.mock('../../reference-data.service.js', () => ({
   ...jest.requireActual('../../reference-data.service.js'),
@@ -64,9 +65,12 @@ jest.mock('@defra-fish/business-rules-lib', () => ({
   START_AFTER_PAYMENT_MINUTES: 30
 }))
 
+jest.mock('../../recurring-payments.service.js')
+
 describe('transaction service', () => {
   beforeAll(() => {
     TRANSACTION_STAGING_TABLE.TableName = 'TestTable'
+    processRecurringPayment.mockResolvedValue({})
   })
 
   beforeEach(jest.clearAllMocks)
@@ -125,6 +129,7 @@ describe('transaction service', () => {
         [
           'licences with a recurring payment',
           () => {
+            processRecurringPayment.mockResolvedValueOnce({ recurringPayment: new RecurringPayment() })
             const mockRecord = mockFinalisedTransactionRecord()
             mockRecord.payment.recurring = {
               name: 'Test name',
@@ -143,9 +148,9 @@ describe('transaction service', () => {
             expect.any(Transaction),
             expect.any(TransactionJournal),
             expect.any(TransactionJournal),
-            expect.any(RecurringPayment),
             expect.any(Contact),
             expect.any(Permission),
+            expect.any(RecurringPayment),
             expect.any(RecurringPaymentInstruction),
             expect.any(ConcessionProof)
           ]
@@ -369,6 +374,43 @@ describe('transaction service', () => {
         expect(paymentJournal.total).toBe(cost)
       })
     })
+
+    describe('recurring payment processing', () => {
+      it('passes transaction record to generateRecurringPaymentRecord', async () => {
+        const callingArgs = {}
+        generateRecurringPaymentRecord.mockImplementationOnce(transaction => {
+          callingArgs.transaction = JSON.parse(JSON.stringify(transaction))
+        })
+        const mockRecord = mockFinalisedTransactionRecord()
+        AwsMock.DynamoDB.DocumentClient.__setResponse('get', { Item: mockRecord })
+        await processQueue({ id: mockRecord.id })
+        // jest.fn args aren't immutable and transaction is changed in processQueue, so we use our clone that hasn't changed
+        expect(callingArgs.transaction).toEqual(mockRecord)
+      })
+
+      it('passes permission to generateRecurringPaymentRecord', async () => {
+        const mockRecord = mockFinalisedTransactionRecord()
+        const expectedPermissionData = {}
+        const keysToCopy = ['referenceNumber', 'issueDate', 'startDate', 'endDate', 'isRenewal']
+        for (const key of keysToCopy) {
+          expectedPermissionData[key] = mockRecord.permissions[0][key]
+        }
+        AwsMock.DynamoDB.DocumentClient.__setResponse('get', { Item: mockRecord })
+
+        await processQueue({ id: mockRecord.id })
+
+        expect(generateRecurringPaymentRecord).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining(expectedPermissionData))
+      })
+
+      it('passes return value of generateRecurringPaymentRecord to processRecurringPayment', async () => {
+        const rprSymbol = Symbol('rpr')
+        const finalisedTransaction = mockFinalisedTransactionRecord()
+        generateRecurringPaymentRecord.mockReturnValueOnce(rprSymbol)
+        AwsMock.DynamoDB.DocumentClient.__setResponse('get', { Item: finalisedTransaction })
+        await processQueue({ id: finalisedTransaction.id })
+        expect(processRecurringPayment).toHaveBeenCalledWith(rprSymbol, expect.any(Contact))
+      })
+    })
   })
 
   describe('.getTransactionJournalRefNumber', () => {

package/src/services/transactions/process-transaction-queue.js

@@ -12,7 +12,7 @@ import {
 } from '@defra-fish/dynamics-lib'
 import { DDE_DATA_SOURCE, FULFILMENT_SWITCHOVER_DATE, POCL_TRANSACTION_SOURCES } from '@defra-fish/business-rules-lib'
 import { getReferenceDataForEntityAndId, getGlobalOptionSetValue, getReferenceDataForEntity } from '../reference-data.service.js'
-import { processRecurringPayment } from '../recurring-payments.service.js'
+import { generateRecurringPaymentRecord, processRecurringPayment } from '../recurring-payments.service.js'
 import { resolveContactPayload } from '../contacts.service.js'
 import { retrieveStagedTransaction } from './retrieve-transaction.js'
 import { TRANSACTION_STAGING_TABLE, TRANSACTION_STAGING_HISTORY_TABLE } from '../../config.js'
@@ -65,11 +65,6 @@ export async function processQueue ({ id }) {
       isRenewal
     )
 
-    const { recurringPayment } = await processRecurringPayment(transactionRecord, contact)
-    if (recurringPayment) {
-      entities.push(recurringPayment)
-    }
-
     permission.bindToEntity(Permission.definition.relationships.licensee, contact)
     permission.bindToEntity(Permission.definition.relationships.permit, permit)
     permission.bindToEntity(Permission.definition.relationships.transaction, transaction)
@@ -78,7 +73,10 @@ export async function processQueue ({ id }) {
 
     entities.push(contact, permission)
 
+    const { recurringPayment } = await processRecurringPayment(generateRecurringPaymentRecord(transactionRecord, permission), contact)
+
     if (recurringPayment && permit.isRecurringPaymentSupported) {
+      entities.push(recurringPayment)
       const paymentInstruction = new RecurringPaymentInstruction()
       paymentInstruction.bindToEntity(RecurringPaymentInstruction.definition.relationships.licensee, contact)
       paymentInstruction.bindToEntity(RecurringPaymentInstruction.definition.relationships.permit, permit)