@defra-fish/sales-api-service 1.60.0-rc.3 → 1.60.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/sales-api-service",
-  "version": "1.60.0-rc.3",
+  "version": "1.60.0",
   "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.60.0-rc.3",
-    "@defra-fish/connectors-lib": "1.60.0-rc.3",
-    "@defra-fish/dynamics-lib": "1.60.0-rc.3",
+    "@defra-fish/business-rules-lib": "1.60.0",
+    "@defra-fish/connectors-lib": "1.60.0",
+    "@defra-fish/dynamics-lib": "1.60.0",
     "@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": "78528be2315fd176a037e49a3507587240deae93"
+  "gitHead": "417b6030d76dace0415cf9b4d1e7cddecb93df99"
 }

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

@@ -1,18 +1,27 @@
-import dueRecurringPayments from '../recurring-payments.js'
-import { getRecurringPayments } from '../../../services/recurring-payments.service.js'
+import recurringPayments from '../recurring-payments.js'
+import { getRecurringPayments, processRPResult } from '../../../services/recurring-payments.service.js'
 
 const [
   {
     options: { handler: drpHandler }
+  },
+  {
+    options: { handler: prpHandler }
   }
-] = dueRecurringPayments
+] = recurringPayments
 
 jest.mock('../../../services/recurring-payments.service.js', () => ({
-  getRecurringPayments: jest.fn()
+  getRecurringPayments: jest.fn(),
+  processRPResult: jest.fn()
 }))
 
-const getMockRequest = ({ date = '2023-10-19' }) => ({
-  params: { date }
+const getMockRequest = ({
+  date = '2023-10-19',
+  transactionId = 'transaction-id',
+  paymentId = 'payment-id',
+  createdDate = 'created-date'
+}) => ({
+  params: { date, transactionId, paymentId, createdDate }
 })
 
 const getMockResponseToolkit = () => ({
@@ -22,16 +31,35 @@ const getMockResponseToolkit = () => ({
 describe('recurring payments', () => {
   beforeEach(jest.clearAllMocks)
 
-  it('handler should return continue response', async () => {
-    const request = getMockRequest({})
-    const responseToolkit = getMockResponseToolkit()
-    expect(await drpHandler(request, responseToolkit)).toEqual(responseToolkit.continue)
+  describe('dueRecurringPayments', () => {
+    it('handler should return continue response', async () => {
+      const request = getMockRequest({})
+      const responseToolkit = getMockResponseToolkit()
+      expect(await drpHandler(request, responseToolkit)).toEqual(responseToolkit.continue)
+    })
+
+    it('should call getRecurringPayments with date', async () => {
+      const date = Symbol('date')
+      const request = getMockRequest({ date })
+      await drpHandler(request, getMockResponseToolkit())
+      expect(getRecurringPayments).toHaveBeenCalledWith(date)
+    })
   })
 
-  it('should call getRecurringPayments with date', async () => {
-    const date = Symbol('date')
-    const request = getMockRequest({ date })
-    await drpHandler(request, getMockResponseToolkit())
-    expect(getRecurringPayments).toHaveBeenCalledWith(date)
+  describe('processRPResult', () => {
+    it('handler should return continue response', async () => {
+      const request = getMockRequest({})
+      const responseToolkit = getMockResponseToolkit()
+      expect(await prpHandler(request, responseToolkit)).toEqual(responseToolkit.continue)
+    })
+
+    it('should call processRPResult with transaction id, payment id and createdDate', async () => {
+      const transactionId = Symbol('transaction-id')
+      const paymentId = Symbol('payment-id')
+      const createdDate = Symbol('created-date')
+      const request = getMockRequest({ transactionId, paymentId, createdDate })
+      await prpHandler(request, getMockResponseToolkit())
+      expect(processRPResult).toHaveBeenCalledWith(transactionId, paymentId, createdDate)
+    })
   })
 })

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

@@ -1,5 +1,6 @@
 import { dueRecurringPaymentsResponseSchema } from '../../schema/recurring-payments.schema.js'
-import { getRecurringPayments } from '../../services/recurring-payments.service.js'
+import { getRecurringPayments, processRPResult } from '../../services/recurring-payments.service.js'
+
 export default [
   {
     method: 'GET',
@@ -21,5 +22,26 @@ export default [
         }
       }
     }
+  },
+  {
+    method: 'GET',
+    path: '/processRPResult/{transactionId}/{paymentId}/{createdDate}',
+    options: {
+      handler: async (request, h) => {
+        const { transactionId, paymentId, createdDate } = request.params
+        const result = await processRPResult(transactionId, paymentId, createdDate)
+        return h.response(result)
+      },
+      description: 'Generate a permission from a recurring payment record',
+      tags: ['api', 'recurring-payments'],
+      plugins: {
+        'hapi-swagger': {
+          responses: {
+            200: { description: 'New permission from recurring payment record generated successfully' }
+          },
+          order: 2
+        }
+      }
+    }
   }
 ]

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

@@ -1,6 +1,20 @@
 import { findDueRecurringPayments, Permission } from '@defra-fish/dynamics-lib'
-import { getRecurringPayments, processRecurringPayment, generateRecurringPaymentRecord } from '../recurring-payments.service.js'
+import {
+  getRecurringPayments,
+  processRecurringPayment,
+  generateRecurringPaymentRecord,
+  processRPResult
+} from '../recurring-payments.service.js'
+import { calculateEndDate, generatePermissionNumber } from '../permissions.service.js'
+import { getObfuscatedDob } from '../contacts.service.js'
 import { createHash } from 'node:crypto'
+import { AWS } from '@defra-fish/connectors-lib'
+import { TRANSACTION_STAGING_TABLE, TRANSACTION_QUEUE } from '../../config.js'
+import { TRANSACTION_STATUS } from '../../services/transactions/constants.js'
+import { retrieveStagedTransaction } from '../../services/transactions/retrieve-transaction.js'
+import { createPaymentJournal, getPaymentJournal, updatePaymentJournal } from '../../services/paymentjournals/payment-journals.service.js'
+import { PAYMENT_JOURNAL_STATUS_CODES, TRANSACTION_SOURCE, PAYMENT_TYPE } from '@defra-fish/business-rules-lib'
+const AWSMocks = {}
 
 jest.mock('@defra-fish/dynamics-lib', () => ({
   ...jest.requireActual('@defra-fish/dynamics-lib'),
@@ -9,6 +23,15 @@ jest.mock('@defra-fish/dynamics-lib', () => ({
   findDueRecurringPayments: jest.fn()
 }))
 
+jest.mock('@defra-fish/connectors-lib', () => {
+  const realConnectors = jest.requireActual('@defra-fish/connectors-lib')
+  return {
+    ...realConnectors,
+    AWS: jest.fn(() => realConnectors.AWS()),
+    receiver: jest.fn()
+  }
+})
+
 jest.mock('node:crypto', () => ({
   createHash: jest.fn(() => ({
     update: () => {},
@@ -16,6 +39,42 @@ jest.mock('node:crypto', () => ({
   }))
 }))
 
+jest.mock('../contacts.service.js', () => ({
+  getObfuscatedDob: jest.fn()
+}))
+
+jest.mock('../permissions.service.js', () => ({
+  calculateEndDate: jest.fn(),
+  generatePermissionNumber: jest.fn()
+}))
+
+jest.mock('../../services/transactions/retrieve-transaction.js', () => ({
+  retrieveStagedTransaction: jest.fn()
+}))
+
+jest.mock('../../services/paymentjournals/payment-journals.service.js', () => ({
+  createPaymentJournal: jest.fn(),
+  getPaymentJournal: jest.fn(),
+  updatePaymentJournal: jest.fn()
+}))
+
+jest.mock('@defra-fish/business-rules-lib', () => ({
+  ADVANCED_PURCHASE_MAX_DAYS: 30,
+  PAYMENT_JOURNAL_STATUS_CODES: {
+    InProgress: 'InProgressCode',
+    Cancelled: 'CancelledCode',
+    Failed: 'FailedCode',
+    Expired: 'ExpiredCode',
+    Completed: 'CompletedCode'
+  },
+  TRANSACTION_SOURCE: {
+    govPay: Symbol('govpay')
+  },
+  PAYMENT_TYPE: {
+    debit: Symbol('debit')
+  }
+}))
+
 const dynamicsLib = jest.requireMock('@defra-fish/dynamics-lib')
 
 const getMockRecurringPayment = () => ({
@@ -88,6 +147,21 @@ const getMockPermission = () => ({
   }
 })
 
+const getMockTransaction = (id = 'test-id') => ({
+  id,
+  dataSource: 'RCP',
+  permissions: [
+    {
+      issueDate: new Date('2024-01-01'),
+      startDate: new Date('2024-01-01'),
+      licensee: {
+        firstName: 'Test',
+        lastName: 'User'
+      }
+    }
+  ]
+})
+
 describe('recurring payments service', () => {
   const createSimpleSampleTransactionRecord = () => ({ payment: { recurring: true }, permissions: [{}] })
   const createSamplePermission = overrides => {
@@ -106,6 +180,19 @@ describe('recurring payments service', () => {
   }
 
   beforeEach(jest.clearAllMocks)
+  beforeAll(() => {
+    TRANSACTION_QUEUE.Url = 'TestUrl'
+    TRANSACTION_STAGING_TABLE.TableName = 'TestTable'
+    const [
+      {
+        value: { docClient, sqs }
+      }
+    ] = AWS.mock.results
+    AWSMocks.docClient = docClient
+    AWSMocks.sqs = sqs
+    Object.freeze(AWSMocks)
+  })
+
   describe('getRecurringPayments', () => {
     it('should equal result of findDueRecurringPayments query', async () => {
       const mockRecurringPayments = [getMockRecurringPayment()]
@@ -339,4 +426,197 @@ describe('recurring payments service', () => {
       expect(rpRecord.payment.recurring).toBeFalsy()
     })
   })
+
+  describe.each(['abc-123', 'hyt678iuhy78uijhgtrfg', 'jhu7i8u7yh-jhu78u'])('processRPResult with transaction id %s', transactionId => {
+    beforeEach(() => {
+      jest.useFakeTimers().setSystemTime(new Date('2024-03-12T09:57:23.745Z'))
+    })
+    afterEach(() => {
+      jest.useRealTimers()
+    })
+    it('should call retrieveStagedTransaction with transaction id', async () => {
+      const mockTransaction = getMockTransaction(transactionId)
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+      await processRPResult(transactionId, '123', '2025-01-01')
+
+      expect(retrieveStagedTransaction).toHaveBeenCalledWith(transactionId)
+    })
+
+    it('should call await getPaymentJournal with transaction id', async () => {
+      const mockTransaction = getMockTransaction(transactionId)
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+      await processRPResult(mockTransaction.id, '123', '2025-01-01')
+
+      expect(retrieveStagedTransaction).toHaveBeenCalledWith(mockTransaction.id)
+    })
+
+    it('if getPaymentJournal is true then updatePaymentJournal is called with expected params', async () => {
+      const mockTransaction = getMockTransaction(transactionId)
+      const paymentId = Symbol('payment-id')
+      const createdDate = Symbol('created-date')
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+      getPaymentJournal.mockResolvedValueOnce(true)
+      const expctedParams = {
+        paymentReference: paymentId,
+        paymentTimestamp: createdDate,
+        paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.InProgress
+      }
+
+      await processRPResult(mockTransaction.id, paymentId, createdDate)
+
+      expect(updatePaymentJournal).toHaveBeenCalledWith(mockTransaction.id, expctedParams)
+    })
+
+    it('if getPaymentJournal is false then updatePaymentJournal is not called', async () => {
+      const mockTransaction = getMockTransaction(transactionId)
+      const paymentId = Symbol('payment-id')
+      const createdDate = Symbol('created-date')
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+      getPaymentJournal.mockResolvedValueOnce(false)
+
+      await processRPResult(mockTransaction.id, paymentId, createdDate)
+
+      expect(updatePaymentJournal).not.toHaveBeenCalled()
+    })
+
+    it('if getPaymentJournal is false then createPaymentJournal is called with expected params', async () => {
+      const mockTransaction = getMockTransaction(transactionId)
+      const paymentId = Symbol('payment-id')
+      const createdDate = Symbol('created-date')
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+      getPaymentJournal.mockResolvedValueOnce(false)
+      const expctedParams = {
+        paymentReference: paymentId,
+        paymentTimestamp: createdDate,
+        paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.InProgress
+      }
+
+      await processRPResult(mockTransaction.id, paymentId, createdDate)
+
+      expect(createPaymentJournal).toHaveBeenCalledWith(mockTransaction.id, expctedParams)
+    })
+
+    it('if getPaymentJournal is true then createPaymentJournal is not called', async () => {
+      const mockTransaction = getMockTransaction(transactionId)
+      const paymentId = Symbol('payment-id')
+      const createdDate = Symbol('created-date')
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+      getPaymentJournal.mockResolvedValueOnce(true)
+
+      await processRPResult(mockTransaction.id, paymentId, createdDate)
+
+      expect(createPaymentJournal).not.toHaveBeenCalled()
+    })
+
+    it('should call calculateEndDate with permission', async () => {
+      const mockTransaction = getMockTransaction(transactionId)
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+      const {
+        permissions: [permission]
+      } = mockTransaction
+
+      await processRPResult(mockTransaction.id, '123', '2025-01-01')
+
+      expect(calculateEndDate).toHaveBeenCalledWith(permission)
+    })
+
+    it('should call generatePermissionNumber with permission and data source', async () => {
+      const mockTransaction = getMockTransaction(transactionId)
+      mockTransaction.dataSource = Symbol('data-source')
+      const {
+        permissions: [permission]
+      } = mockTransaction
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+
+      await processRPResult(mockTransaction.id, '123', '2025-01-01')
+
+      expect(generatePermissionNumber).toHaveBeenCalledWith(permission, mockTransaction.dataSource)
+    })
+
+    it('should call getObfuscatedDob with licensee', async () => {
+      const mockTransaction = getMockTransaction(transactionId)
+      const {
+        permissions: [permission]
+      } = mockTransaction
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+
+      await processRPResult(mockTransaction.id, '123', '2025-01-01')
+
+      expect(getObfuscatedDob).toHaveBeenCalledWith(permission.licensee)
+    })
+
+    it('should call AWSMocks.docClient.createUpdateExpression with payload, permissions, status and payment details', async () => {
+      jest.spyOn(AWSMocks.docClient, 'createUpdateExpression')
+      const fakeNow = '2024-03-19T14:09:00.000Z'
+      jest.setSystemTime(new Date(fakeNow))
+      const mockTransaction = getMockTransaction(transactionId)
+      const permission = {
+        issueDate: fakeNow,
+        dataSource: 'RCP',
+        licensee: {
+          firstName: 'Brenin',
+          lastName: 'Pysgotwr',
+          obfuscatedDob: '987654678'
+        },
+        startDate: '2025-03-19T00:00:00.000Z'
+      }
+      const expectedPermission = {
+        ...permission,
+        startDate: '2025-03-19T00:00:00.000Z',
+        endDate: '2026-03-18T23:59:59.999Z',
+        referenceNumber: '123abc'
+      }
+      mockTransaction.cost = 23.46
+      mockTransaction.permissions = [permission]
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+      generatePermissionNumber.mockReturnValueOnce(expectedPermission.referenceNumber)
+      calculateEndDate.mockReturnValueOnce(expectedPermission.endDate)
+
+      await processRPResult(transactionId, '123abc', '2025-01-01')
+
+      expect(AWSMocks.docClient.createUpdateExpression).toHaveBeenCalledWith({
+        payload: expect.objectContaining(expectedPermission),
+        permissions: expect.arrayContaining([expectedPermission]),
+        status: expect.objectContaining({ id: TRANSACTION_STATUS.FINALISED }),
+        payment: expect.objectContaining({
+          amount: mockTransaction.cost,
+          method: TRANSACTION_SOURCE.govPay,
+          source: PAYMENT_TYPE.debit,
+          timestamp: fakeNow
+        })
+      })
+    })
+
+    it('should call AWSMocks.docClient.update with expected params', async () => {
+      jest.spyOn(AWSMocks.docClient, 'createUpdateExpression')
+      const mockTransaction = getMockTransaction(transactionId)
+      mockTransaction.cost = 38.72
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+      const updateExpression = { expression: Symbol('update expression') }
+      AWSMocks.docClient.createUpdateExpression.mockReturnValue(updateExpression)
+
+      await processRPResult(mockTransaction.id, '123', '2025-01-01')
+
+      expect(AWSMocks.docClient.update).toHaveBeenCalledWith({
+        TableName: TRANSACTION_STAGING_TABLE.TableName,
+        Key: { id: transactionId },
+        ...updateExpression,
+        ReturnValues: 'ALL_NEW'
+      })
+    })
+
+    it('should call AWSMocks.sqs.sendMessage with expected params', async () => {
+      const mockTransaction = getMockTransaction(transactionId)
+      retrieveStagedTransaction.mockResolvedValueOnce(mockTransaction)
+
+      await processRPResult(mockTransaction.id, '123', '2025-01-01')
+
+      expect(AWSMocks.sqs.sendMessage).toHaveBeenCalledWith({
+        QueueUrl: TRANSACTION_QUEUE.Url,
+        MessageGroupId: transactionId,
+        MessageDeduplicationId: transactionId,
+        MessageBody: JSON.stringify({ id: transactionId })
+      })
+    })
+  })
 })

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

@@ -1,7 +1,15 @@
 import { executeQuery, findDueRecurringPayments, RecurringPayment } from '@defra-fish/dynamics-lib'
+import { calculateEndDate, generatePermissionNumber } from './permissions.service.js'
+import { getObfuscatedDob } from './contacts.service.js'
 import { createHash } from 'node:crypto'
-import { ADVANCED_PURCHASE_MAX_DAYS } from '@defra-fish/business-rules-lib'
+import { ADVANCED_PURCHASE_MAX_DAYS, PAYMENT_JOURNAL_STATUS_CODES, PAYMENT_TYPE, TRANSACTION_SOURCE } from '@defra-fish/business-rules-lib'
+import { TRANSACTION_STAGING_TABLE, TRANSACTION_QUEUE } from '../config.js'
+import { TRANSACTION_STATUS } from '../services/transactions/constants.js'
+import { retrieveStagedTransaction } from '../services/transactions/retrieve-transaction.js'
+import { createPaymentJournal, getPaymentJournal, updatePaymentJournal } from '../services/paymentjournals/payment-journals.service.js'
 import moment from 'moment'
+import { AWS } from '@defra-fish/connectors-lib'
+const { sqs, docClient } = AWS()
 
 export const getRecurringPayments = date => executeQuery(findDueRecurringPayments(date))
 
@@ -65,3 +73,56 @@ export const processRecurringPayment = async (transactionRecord, contact) => {
   }
   return { recurringPayment: null }
 }
+
+export const processRPResult = async (transactionId, paymentId, createdDate) => {
+  const transactionRecord = await retrieveStagedTransaction(transactionId)
+  if (await getPaymentJournal(transactionId)) {
+    await updatePaymentJournal(transactionId, {
+      paymentReference: paymentId,
+      paymentTimestamp: createdDate,
+      paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.InProgress
+    })
+  } else {
+    await createPaymentJournal(transactionId, {
+      paymentReference: paymentId,
+      paymentTimestamp: createdDate,
+      paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.InProgress
+    })
+  }
+  const [permission] = transactionRecord.permissions
+  permission.issueDate = new Date().toISOString()
+
+  permission.endDate = await calculateEndDate(permission)
+  permission.referenceNumber = await generatePermissionNumber(permission, transactionRecord.dataSource)
+  permission.licensee.obfuscatedDob = await getObfuscatedDob(permission.licensee)
+
+  await docClient
+    .update({
+      TableName: TRANSACTION_STAGING_TABLE.TableName,
+      Key: { id: transactionId },
+      ...docClient.createUpdateExpression({
+        payload: permission,
+        permissions: transactionRecord.permissions,
+        status: { id: TRANSACTION_STATUS.FINALISED },
+        payment: {
+          amount: transactionRecord.cost,
+          method: TRANSACTION_SOURCE.govPay,
+          source: PAYMENT_TYPE.debit,
+          timestamp: new Date().toISOString()
+        }
+      }),
+      ReturnValues: 'ALL_NEW'
+    })
+    .promise()
+
+  await sqs
+    .sendMessage({
+      QueueUrl: TRANSACTION_QUEUE.Url,
+      MessageGroupId: transactionId,
+      MessageDeduplicationId: transactionId,
+      MessageBody: JSON.stringify({ id: transactionId })
+    })
+    .promise()
+
+  return { permission }
+}