@defra-fish/sales-api-service 1.63.0-rc.1 → 1.63.0-rc.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/sales-api-service",
-  "version": "1.63.0-rc.1",
+  "version": "1.63.0-rc.11",
   "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.63.0-rc.1",
-    "@defra-fish/connectors-lib": "1.63.0-rc.1",
-    "@defra-fish/dynamics-lib": "1.63.0-rc.1",
+    "@defra-fish/business-rules-lib": "1.63.0-rc.11",
+    "@defra-fish/connectors-lib": "1.63.0-rc.11",
+    "@defra-fish/dynamics-lib": "1.63.0-rc.11",
     "@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": "93c7097feecf01ce2d207cafe43227f7aaa77376"
+  "gitHead": "7d0e5dab76d8aebb0dbaecb857c3d44fdc6f79f9"
 }

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

@@ -33,10 +33,10 @@ const getResponseSampleData = () => ({
         mobilePhone: null,
         organisation: null,
         premises: '1',
-        street: 'Catharine Place',
+        street: 'Test Street',
         locality: null,
-        town: 'Bath',
-        postcode: 'BA1 2PR'
+        town: 'Testville',
+        postcode: 'TE1 1ST'
       }
     },
     activePermission: {
@@ -166,3 +166,19 @@ describe('cancelRecurringPaymentRequestParamsSchema', () => {
     expect(() => cancelRecurringPaymentRequestParamsSchema.validateAsync(sampleData).rejects.toThrow())
   })
 })
+
+describe('cancelRecurringPaymentRequestParamsSchema', () => {
+  it('validates expected object', async () => {
+    const sampleData = { id: 'abc123' }
+    expect(() => cancelRecurringPaymentRequestParamsSchema.validateAsync(sampleData)).not.toThrow()
+  })
+
+  it('throws an error if id missing', async () => {
+    expect(() => cancelRecurringPaymentRequestParamsSchema.validateAsync({}).rejects.toThrow())
+  })
+
+  it('throws an error if id is not the correct type', async () => {
+    const sampleData = { id: 99 }
+    expect(() => cancelRecurringPaymentRequestParamsSchema.validateAsync(sampleData).rejects.toThrow())
+  })
+})

package/src/schema/__tests__/transaction.schema.spec.js

@@ -1,4 +1,9 @@
-import { createTransactionSchema, createTransactionResponseSchema, finaliseTransactionResponseSchema } from '../transaction.schema.js'
+import {
+  createTransactionSchema,
+  createTransactionResponseSchema,
+  finaliseTransactionResponseSchema,
+  retrieveStagedTransactionParamsSchema
+} from '../transaction.schema.js'
 import { mockTransactionPayload, mockStagedTransactionRecord, mockFinalisedTransactionRecord } from '../../__mocks__/test-data.js'
 
 jest.mock('../validators/validators.js', () => ({
@@ -96,27 +101,42 @@ describe('createTransactionSchema', () => {
     await expect(createTransactionSchema.validateAsync(mockPayload)).rejects.toThrow()
   })
 
-  it('validates successfully when an agreementId is supplied', async () => {
+  it('validates successfully when recurring payment detail is supplied', async () => {
     const mockPayload = mockTransactionPayload()
-    mockPayload.agreementId = 't3jl08v2nqqmujrnhs09pmhtjx'
+    mockPayload.recurringPayment = {
+      agreementId: 't3jl08v2nqqmujrnhs09pmhtjx',
+      id: 'fdc73d20-a0bf-4da6-9a49-2f0a24bd3509'
+    }
     await expect(createTransactionSchema.validateAsync(mockPayload)).resolves.not.toThrow()
   })
 
-  it('validates successfully when agreementId is omitted', async () => {
+  it('validates successfully when recurring payment detail is omitted', async () => {
     const mockPayload = mockTransactionPayload()
     await expect(createTransactionSchema.validateAsync(mockPayload)).resolves.not.toThrow()
   })
 
+  it('fails validation if agreement id is omitted from recurring payment detail', async () => {
+    const mockPayload = mockTransactionPayload()
+    mockPayload.recurringPayment = { id: 'fdc73d20-a0bf-4da6-9a49-2f0a24bd3509' }
+    await expect(() => createTransactionSchema.validateAsync(mockPayload)).rejects.toThrow()
+  })
+
   it.each([
-    ['too short string', 'foo'],
-    ['too long string', 'foobarbazfoobarbazfoobarbaz'],
-    ['string containing invalid characters', '!3j@08v2nqqmujrnhs09_mhtjx'],
-    ['null', null],
-    ['numeric', 4567]
-  ])('fails validation when provided with a %s for agreementId', async (_d, agreementId) => {
+    ['agreement id is too long', { agreementId: 'thisistoolongtobeanagreementid' }],
+    ['agreement id is too short', { agreementId: 'tooshorttobeanagreementid' }],
+    ['agreement id contains invalid characters', '!3j@08v2nqqmujrnhs09_mhtjx'],
+    ['agreement id is null', { agreementId: null }],
+    ['agreement id is a numeric', { agreementId: 4567 }],
+    ['id is not a guid', { id: 'not-a-guid' }],
+    ['id is null', { id: null }]
+  ])('fails validation if %s', async (_d, recurringPayment) => {
     const mockPayload = mockTransactionPayload()
-    mockPayload.agreementId = agreementId
-    await expect(createTransactionSchema.validateAsync(mockPayload)).rejects.toThrow()
+    mockPayload.recurringPayment = {
+      agreementId: 'jhyu78iujhy7u87y6thu87uyj8',
+      id: '7a0660ec-8535-4357-b925-e598a9358119',
+      ...recurringPayment
+    }
+    await expect(() => createTransactionSchema.validateAsync(mockPayload)).rejects.toThrow()
   })
 })
 
@@ -135,3 +155,32 @@ describe('finaliseTransactionResponseSchema', () => {
     expect(result).toBeInstanceOf(Object)
   })
 })
+
+describe('retrieveStagedTransactionParamsSchema', () => {
+  it.each([
+    ['36fb757c-6377-49c5-ab6e-32eb9782fcf0'],
+    ['c290b78d-3bbc-4445-b4dd-b36f6ee044a2'],
+    ['2323a890-b36f-47b1-ab9f-d60e292ac4ae'],
+    ['9c6b79be-28be-4916-aa5c-08520aa1e804']
+  ])('validates successfully when a uuid v4 transactionId is %s', async transactionId => {
+    const sampleData = { id: transactionId }
+    await expect(retrieveStagedTransactionParamsSchema.validateAsync(sampleData)).resolves.not.toThrow()
+  })
+
+  it.each([
+    ['uuid1 string', '5a429f62-871b-11ef-b864-0242ac120002'],
+    ['uuid2 string', '000003e8-871b-21ef-8000-325096b39f47'],
+    ['uuid3 string', 'a3bb189e-8bf9-3888-9912-ace4e6543002'],
+    ['uuid5 string', 'a6edc906-2f9f-5fb2-a373-efac406f0ef2'],
+    ['uuid6 string', 'a3bb189e-8bf9-3888-9912-ace4e6543002'],
+    ['uuid7 string', '01927705-ffac-77b5-89af-c97451b1bbe2'],
+    ['numeric', 4567]
+  ])('fails validation when provided with a %s for transactionId', async (_d, transactionId) => {
+    const sampleData = { id: transactionId }
+    await expect(() => retrieveStagedTransactionParamsSchema.validateAsync(sampleData)).rejects.toThrow()
+  })
+
+  it('throws an error if id missing', async () => {
+    await expect(() => retrieveStagedTransactionParamsSchema.validateAsync({}).rejects.toThrow())
+  })
+})

package/src/schema/transaction.schema.js

@@ -36,7 +36,10 @@ const createTransactionRequestSchemaContent = {
   createdBy: Joi.string().optional(),
   journalId: Joi.string().optional(),
   transactionId: Joi.string().guid({ version: 'uuidv4' }).optional(),
-  agreementId: Joi.string().alphanum().length(AGREEMENT_ID_LENGTH).optional()
+  recurringPayment: Joi.object({
+    agreementId: Joi.string().alphanum().length(AGREEMENT_ID_LENGTH).required(),
+    id: Joi.string().guid()
+  }).optional()
 }
 
 /**
@@ -153,3 +156,7 @@ export const finaliseTransactionResponseSchema = Joi.object({
     .required()
     .label('finalise-transaction-status')
 }).label('finalise-transaction-response')
+
+export const retrieveStagedTransactionParamsSchema = Joi.object({
+  id: Joi.string().guid({ version: 'uuidv4' }).required()
+})

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

@@ -2,9 +2,19 @@ import initialiseServer from '../server.js'
 import Boom from '@hapi/boom'
 import dotProp from 'dot-prop'
 import { SERVER } from '../../config.js'
+import fs from 'fs'
+
+jest.mock('fs', () => {
+  const actual = jest.requireActual('fs')
+  return {
+    ...actual,
+    readFileSync: jest.fn(() => JSON.stringify({ name: 'sales-api-test', version: '1.2.3' }))
+  }
+})
 
 describe('hapi server', () => {
   describe('initialisation', () => {
+    const serverInfoUri = 'test'
     let serverConfigSpy
     beforeAll(() => {
       const Hapi = jest.requireActual('@hapi/hapi')
@@ -15,7 +25,7 @@ describe('hapi server', () => {
         register: jest.fn(),
         route: jest.fn(),
         info: {
-          uri: 'test'
+          uri: serverInfoUri
         },
         listener: {}
       }))
@@ -48,6 +58,22 @@ describe('hapi server', () => {
         headersTimeout: 5123
       })
     })
+
+    it('logs startup details including name and version', async () => {
+      const mockPkg = { name: 'sales-api-test', version: '1.2.3' }
+      fs.readFileSync.mockReturnValue(JSON.stringify(mockPkg))
+      const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+
+      await initialiseServer({ port: 4000 })
+
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Server started at %s. Listening on %s. name: %s. version: %s'),
+        expect.any(String),
+        serverInfoUri,
+        mockPkg.name,
+        mockPkg.version
+      )
+    })
   })
 
   describe('configuration', () => {

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

@@ -1,6 +1,10 @@
 import initialiseServer from '../../server.js'
 import { mockTransactionPayload, mockStagedTransactionRecord } from '../../../__mocks__/test-data.js'
 import { v4 as uuidv4 } from 'uuid'
+import { retrieveStagedTransactionParamsSchema } from '../../../schema/transaction.schema.js'
+import { retrieveStagedTransaction } from '../../../services/transactions/retrieve-transaction.js'
+import transactions from '../transactions.js'
+
 jest.mock('../../../services/transactions/transactions.service.js', () => ({
   createTransaction: jest.fn(async () => mockStagedTransactionRecord()),
   createTransactions: jest.fn(async payloads => Array(payloads.length).fill(mockStagedTransactionRecord())),
@@ -9,6 +13,10 @@ jest.mock('../../../services/transactions/transactions.service.js', () => ({
   processDlq: jest.fn(async () => {})
 }))
 
+jest.mock('../../../services/transactions/retrieve-transaction.js', () => ({
+  retrieveStagedTransaction: jest.fn()
+}))
+
 jest.mock('../../../schema/validators/validators.js', () => ({
   ...jest.requireActual('../../../schema/validators/validators.js'),
   createOptionSetValidator: () => async () => undefined,
@@ -18,6 +26,20 @@ jest.mock('../../../schema/validators/validators.js', () => ({
   createPermitConcessionValidator: () => async () => undefined
 }))
 
+jest.mock('@defra-fish/connectors-lib', () => {
+  const awsMock = {
+    docClient: {
+      get: jest.fn(() => ({ Item: { id: 'abc123' } }))
+    }
+  }
+  return {
+    AWS: jest.fn(() => awsMock),
+    airbrake: {
+      initialise: jest.fn()
+    }
+  }
+})
+
 let server = null
 
 describe('transaction handler', () => {
@@ -214,4 +236,30 @@ describe('transaction handler', () => {
       expect(result).toBeUnprocessableEntityErrorResponse()
     })
   })
+
+  describe('retrieveStagedTransaction', () => {
+    const getMockRequest = ({ id = 'abc123' }) => ({ params: { id } })
+    const getMockResponseToolkit = () => ({ response: jest.fn() })
+    const retrieveHandler = transactions[transactions.length - 1].options.handler
+
+    it('handler should return continue response', async () => {
+      const request = getMockRequest({})
+      const responseToolkit = getMockResponseToolkit()
+      expect(await retrieveHandler(request, responseToolkit)).toEqual(responseToolkit.continue)
+    })
+
+    it('should call retrieveStagedTransaction with id', async () => {
+      const id = 'transaction-id'
+      const request = getMockRequest({ id })
+      await retrieveHandler(request, getMockResponseToolkit())
+      expect(retrieveStagedTransaction).toHaveBeenCalledWith(id)
+    })
+
+    it('should validate with cancelRecurringPaymentRequestParamsSchema', async () => {
+      const id = 'transaction-id'
+      const request = getMockRequest({ id })
+      await retrieveHandler(request, getMockResponseToolkit())
+      expect(transactions[5].options.validate.params).toBe(retrieveStagedTransactionParamsSchema)
+    })
+  })
 })

package/src/server/routes/transactions.js

@@ -7,6 +7,7 @@ import {
   processQueue,
   processDlq
 } from '../../services/transactions/transactions.service.js'
+import { retrieveStagedTransaction } from '../../services/transactions/retrieve-transaction.js'
 import {
   createTransactionSchema,
   createTransactionResponseSchema,
@@ -14,6 +15,7 @@ import {
   createTransactionBatchResponseSchema,
   finaliseTransactionRequestSchema,
   finaliseTransactionResponseSchema,
+  retrieveStagedTransactionParamsSchema,
   BATCH_CREATE_MAX_COUNT
 } from '../../schema/transaction.schema.js'
 import db from 'debug'
@@ -174,5 +176,29 @@ export default [
         }
       }
     }
+  },
+  {
+    method: 'GET',
+    path: '/retrieveStagedTransaction/{id}',
+    options: {
+      handler: async (request, h) => {
+        const { id } = request.params
+        const result = await retrieveStagedTransaction(id)
+        return h.response(result)
+      },
+      description: 'Retrieve a staged transaction',
+      tags: ['api', 'transactions'],
+      validate: {
+        params: retrieveStagedTransactionParamsSchema
+      },
+      plugins: {
+        'hapi-swagger': {
+          responses: {
+            200: { description: 'Staged transaction retreived' }
+          },
+          order: 5
+        }
+      }
+    }
   }
 ]

package/src/server/server.js

@@ -8,6 +8,8 @@ import Boom from '@hapi/boom'
 import { SERVER } from '../config.js'
 import moment from 'moment'
 import { airbrake } from '@defra-fish/connectors-lib'
+import path from 'path'
+import fs from 'fs'
 
 export default async (opts = { port: SERVER.Port }) => {
   airbrake.initialise()
@@ -49,7 +51,17 @@ export default async (opts = { port: SERVER.Port }) => {
   server.route(Routes)
 
   await server.start()
-  console.log('Server started at %s. Listening on %s', moment().toISOString(), server.info.uri)
+
+  const pkgPath = path.join(process.cwd(), 'package.json')
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+
+  console.log(
+    'Server started at %s. Listening on %s. name: %s. version: %s',
+    moment().toISOString(),
+    server.info.uri,
+    pkg.name,
+    pkg.version
+  )
 
   const shutdown = async code => {
     await server.stop()

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

@@ -5,6 +5,7 @@ import {
   findRecurringPaymentsByAgreementId,
   findById,
   Permission,
+  persist,
   RecurringPayment
 } from '@defra-fish/dynamics-lib'
 import {
@@ -48,7 +49,8 @@ jest.mock('@defra-fish/dynamics-lib', () => ({
   findRecurringPaymentsByAgreementId: jest.fn(() => ({ toRetrieveRequest: () => {} })),
   dynamicsClient: {
     retrieveMultipleRequest: jest.fn(() => ({ value: [] }))
-  }
+  },
+  persist: jest.fn()
 }))
 
 jest.mock('@defra-fish/connectors-lib', () => ({
@@ -392,7 +394,9 @@ describe('recurring payments service', () => {
           ...permission
         }
       ],
-      agreementId,
+      recurringPayment: {
+        agreementId
+      },
       payment: {
         amount: 35.8,
         source: 'Gov Pay',
@@ -528,6 +532,15 @@ describe('recurring payments service', () => {
       await expect(generateRecurringPaymentRecord(sampleTransaction)).rejects.toThrow('Invalid dates provided for permission')
     })
 
+    it('returns a false flag when recurringPayment is not present', async () => {
+      const sampleTransaction = createFinalisedSampleTransaction()
+      delete sampleTransaction.recurringPayment
+
+      const rpRecord = await generateRecurringPaymentRecord(sampleTransaction)
+
+      expect(rpRecord.payment?.recurring).toBeFalsy()
+    })
+
     it('returns a false flag when agreementId is not present', async () => {
       const sampleTransaction = createFinalisedSampleTransaction(
         null,
@@ -859,28 +872,29 @@ describe('recurring payments service', () => {
 
   describe('cancelRecurringPayment', () => {
     it('should call findById with RecurringPayment and the provided id', async () => {
+      findById.mockReturnValueOnce(getMockRecurringPayment())
       const id = 'abc123'
       await cancelRecurringPayment(id)
       expect(findById).toHaveBeenCalledWith(RecurringPayment, id)
     })
 
-    it('should log a RecurringPayment record when there is one match', async () => {
-      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(jest.fn())
-      const recurringPayment = { entity: getMockRecurringPayment() }
+    it('should call persist with the updated RecurringPayment', async () => {
+      const recurringPayment = getMockRecurringPayment()
       findById.mockReturnValueOnce(recurringPayment)
 
+      const cancelledDate = new Date().toISOString().split('T')[0]
+      const cancelledReason = { description: 'Payment Failure', id: 910400002, label: 'Payment Failure' }
+      const expectedUpdatedRecurringPayment = { ...recurringPayment, cancelledReason, cancelledDate }
+
       await cancelRecurringPayment('id')
 
-      expect(consoleLogSpy).toHaveBeenCalledWith('RecurringPayment for cancellation: ', recurringPayment)
+      expect(persist).toHaveBeenCalledWith([expect.objectContaining(expectedUpdatedRecurringPayment)])
     })
 
-    it('should log no matches when there are no matches', async () => {
-      const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(jest.fn())
+    it('should raise an error when there are no matches', async () => {
       findById.mockReturnValueOnce(undefined)
 
-      await cancelRecurringPayment('id')
-
-      expect(consoleLogSpy).toHaveBeenCalledWith('No matches found for cancellation')
+      await expect(cancelRecurringPayment('id')).rejects.toThrow('Invalid id provided for recurring payment cancellation')
     })
   })
 })

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

@@ -1,10 +1,11 @@
 import {
+  dynamicsClient,
   executeQuery,
   findById,
   findDueRecurringPayments,
   findRecurringPaymentsByAgreementId,
-  RecurringPayment,
-  dynamicsClient
+  persist,
+  RecurringPayment
 } from '@defra-fish/dynamics-lib'
 import { calculateEndDate, generatePermissionNumber } from './permissions.service.js'
 import { getObfuscatedDob } from './contacts.service.js'
@@ -14,6 +15,7 @@ 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 { getGlobalOptionSetValue } from './reference-data.service.js'
 import moment from 'moment'
 import { AWS, govUkPayApi } from '@defra-fish/connectors-lib'
 import db from 'debug'
@@ -37,8 +39,8 @@ const getNextDueDate = (startDate, issueDate, endDate) => {
 }
 
 export const generateRecurringPaymentRecord = async (transactionRecord, permission) => {
-  if (transactionRecord.agreementId) {
-    const agreementResponse = await getRecurringPaymentAgreement(transactionRecord.agreementId)
+  if (transactionRecord.recurringPayment?.agreementId) {
+    const agreementResponse = await getRecurringPaymentAgreement(transactionRecord.recurringPayment.agreementId)
     const lastDigitsCardNumbers = agreementResponse.payment_instrument?.card_details?.last_digits_card_number
     const [{ startDate, issueDate, endDate }] = transactionRecord.permissions
     return {
@@ -49,7 +51,7 @@ export const generateRecurringPaymentRecord = async (transactionRecord, permissi
           cancelledDate: null,
           cancelledReason: null,
           endDate,
-          agreementId: transactionRecord.agreementId,
+          agreementId: transactionRecord.recurringPayment.agreementId,
           status: 1,
           last_digits_card_number: lastDigitsCardNumbers
         }
@@ -165,9 +167,14 @@ export const findNewestExistingRecurringPaymentInCrm = async agreementId => {
 export const cancelRecurringPayment = async id => {
   const recurringPayment = await findById(RecurringPayment, id)
   if (recurringPayment) {
-    console.log('RecurringPayment for cancellation: ', recurringPayment)
+    const data = recurringPayment
+    data.cancelledDate = new Date().toISOString().split('T')[0]
+    data.cancelledReason = await getGlobalOptionSetValue(RecurringPayment.definition.mappings.cancelledReason.ref, 'Payment Failure')
+    const updatedRecurringPayment = Object.assign(new RecurringPayment(), data)
+    await persist([updatedRecurringPayment])
+    return updatedRecurringPayment
   } else {
-    console.log('No matches found for cancellation')
+    throw new Error('Invalid id provided for recurring payment cancellation')
   }
 }