@defra-fish/payment-mop-up-job 1.63.0-rc.0 → 1.63.0-rc.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/payment-mop-up-job",
-  "version": "1.63.0-rc.0",
+  "version": "1.63.0-rc.10",
   "description": "Process incomplete web-sales",
   "type": "module",
   "engines": {
@@ -36,11 +36,11 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@defra-fish/business-rules-lib": "1.63.0-rc.0",
-    "@defra-fish/connectors-lib": "1.63.0-rc.0",
+    "@defra-fish/business-rules-lib": "1.63.0-rc.10",
+    "@defra-fish/connectors-lib": "1.63.0-rc.10",
     "bottleneck": "^2.19.5",
     "debug": "^4.3.3",
     "moment": "^2.29.1"
   },
-  "gitHead": "127bd6db86a97eb1b229f3de30e27046119ffca6"
+  "gitHead": "c4301461b148cbf244c1bb5c834521243ec0a534"
 }

package/src/__tests__/payment-mop-up-job.spec.js

@@ -1,3 +1,5 @@
+import fs from 'fs'
+
 global.simulateLockError = false
 global.lockReleased = false
 jest.mock('@defra-fish/connectors-lib', () => ({
@@ -20,6 +22,13 @@ jest.mock('@defra-fish/connectors-lib', () => ({
   })
 }))
 
+jest.mock('fs', () => ({
+  readFileSync: jest.fn(),
+  promises: {
+    readFile: jest.fn()
+  }
+}))
+
 describe('payment-mop-up-job', () => {
   beforeEach(() => {
     jest.clearAllMocks()
@@ -27,6 +36,22 @@ describe('payment-mop-up-job', () => {
     global.lockReleased = false
   })
 
+  it('logs startup details including name and version', () => {
+    const mockPkg = { name: 'payment-mop-up-test', version: '1.2.3' }
+    fs.readFileSync.mockReturnValue(JSON.stringify(mockPkg))
+
+    jest.isolateModules(() => {
+      const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+      require('../payment-mop-up-job.js')
+      expect(logSpy).toHaveBeenCalledWith(
+        'Payment mop up job starting at %s. name: %s. version: %s',
+        expect.any(String),
+        mockPkg.name,
+        mockPkg.version
+      )
+    })
+  })
+
   it('starts the mop up job with --age-minutes=3 and --scan-duration=67', done => {
     jest.isolateModules(() => {
       const mockExecute = jest.fn()

package/src/payment-mop-up-job.js

@@ -1,10 +1,17 @@
+'use strict'
 import { execute } from './processors/processor.js'
 import { DEFAULT_INCOMPLETE_PURCHASE_AGE_MINUTES, DEFAULT_SCAN_DURATION_HOURS } from './constants.js'
 import { DistributedLock, airbrake } from '@defra-fish/connectors-lib'
+import path from 'path'
+import fs from 'fs'
+
+const pkgPath = path.join(process.cwd(), 'package.json')
+const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+
+console.log('Payment mop up job starting at %s. name: %s. version: %s', new Date().toISOString(), pkg.name, pkg.version)
 
 const incompletePurchaseAgeMinutes = Number(process.env.INCOMPLETE_PURCHASE_AGE_MINUTES || DEFAULT_INCOMPLETE_PURCHASE_AGE_MINUTES)
 const scanDurationHours = Number(process.env.SCAN_DURATION_HOURS || DEFAULT_SCAN_DURATION_HOURS)
-
 const lock = new DistributedLock('payment-mop-up-etl', 5 * 60 * 1000)
 airbrake.initialise()
 lock

package/src/processors/__tests__/processor.spec.js

@@ -1,11 +1,17 @@
 import { salesApi, govUkPayApi } from '@defra-fish/connectors-lib'
 import { execute } from '../processor.js'
-import { GOVUK_PAY_ERROR_STATUS_CODES, PAYMENT_JOURNAL_STATUS_CODES } from '@defra-fish/business-rules-lib'
+import { GOVUK_PAY_ERROR_STATUS_CODES, PAYMENT_JOURNAL_STATUS_CODES, PAYMENT_STATUS } from '@defra-fish/business-rules-lib'
 import moment from 'moment'
 
 jest.mock('@defra-fish/connectors-lib')
+// mock bottleneck to speed up test execution
+jest.mock('bottleneck', () =>
+  jest.fn(function () {
+    this.wrap = fn => fn
+  })
+)
 
-const journalEntries = [
+const journalEntries = () => [
   {
     id: '4fa393ab-07f4-407e-b233-89be2a6f5f77',
     paymentStatus: 'In Progress',
@@ -80,7 +86,8 @@ const govUkPayStatusEntries = [
   }
 ]
 
-const govUkPayStatusNotFound = { code: 'P0200', description: 'Not found' }
+// differs from other responses - see https://docs.payments.service.gov.uk/api_reference/#gov-uk-pay-api-error-codes
+const govUkPayStatusNotFound = () => ({ code: 'P0200', description: 'Not found' })
 
 const createPaymentEventsEntry = paymentStatus => {
   return {
@@ -122,22 +129,20 @@ describe('processor', () => {
   beforeEach(jest.clearAllMocks)
 
   it('completes normally where there are no journal records retrieved', async () => {
-    salesApi.paymentJournals.getAll.mockReturnValue([])
-    govUkPayApi.fetchPaymentStatus.mockImplementation(jest.fn())
+    salesApi.paymentJournals.getAll.mockReturnValueOnce([])
     await execute(1, 1)
     expect(govUkPayApi.fetchPaymentStatus).not.toHaveBeenCalled()
   })
 
   it('completes normally where there are journal records retrieved', async () => {
-    salesApi.paymentJournals.getAll.mockReturnValue(journalEntries)
-    salesApi.updatePaymentJournal.mockImplementation(jest.fn())
-    salesApi.finaliseTransaction.mockImplementation(jest.fn())
+    salesApi.paymentJournals.getAll.mockReturnValueOnce(journalEntries())
     govUkPayStatusEntries.forEach(status => {
       govUkPayApi.fetchPaymentStatus.mockReturnValueOnce({ json: async () => status })
       govUkPayApi.fetchPaymentEvents.mockReturnValueOnce({ json: async () => createPaymentEventsEntry(status) })
     })
 
     await execute(1, 1)
+
     expect(govUkPayApi.fetchPaymentStatus).toHaveBeenCalledTimes(govUkPayStatusEntries.length)
     expect(govUkPayApi.fetchPaymentEvents).toHaveBeenCalledTimes(govUkPayStatusEntries.filter(s => s.state.status === 'success').length)
     expect(salesApi.finaliseTransaction).toHaveBeenCalledTimes(govUkPayStatusEntries.filter(s => s.state.status === 'success').length)
@@ -161,48 +166,146 @@ describe('processor', () => {
     })
   })
 
-  describe('Result not present in GovPay', () => {
-    const NOT_FOUND_ID = journalEntries[2].id
-    const NOT_FOUND_PAYMENT_REFERENCE = journalEntries[2].paymentReference
-    beforeEach(() => {
-      salesApi.paymentJournals.getAll.mockReturnValue(journalEntries)
-      salesApi.updatePaymentJournal.mockImplementation(() => {})
-      salesApi.finaliseTransaction.mockImplementation(() => {})
+  it('calls fetchPaymentStatus with recurring as true since agreementId exists', async () => {
+    salesApi.retrieveStagedTransaction.mockReturnValueOnce({ recurringPayment: { agreementId: '123' } })
+    const paymentReference = '15nioqikvvnuu5l8m2qeaj0qap'
+    salesApi.paymentJournals.getAll.mockReturnValueOnce([
+      {
+        id: 'a0e0e5c3-1004-4271-80ba-d05eda3e8220',
+        paymentStatus: 'In Progress',
+        paymentReference,
+        paymentTimestamp: '2020-06-01T10:35:56.873Z'
+      }
+    ])
+    govUkPayApi.fetchPaymentStatus.mockResolvedValueOnce({
+      json: async () => ({ state: { status: 'success' } })
+    })
+    govUkPayApi.fetchPaymentEvents.mockResolvedValueOnce({
+      json: async () => ({ events: [{ state: { status: 'success' }, updated: '2020-06-01T10:35:56.873Z' }] })
+    })
+
+    await execute(1, 1)
+
+    expect(govUkPayApi.fetchPaymentStatus).toHaveBeenCalledWith(paymentReference, true)
+  })
+
+  it('calls fetchPaymentStatus with recurring as false since agreementId does not exist', async () => {
+    const paymentReference = '25nioqikvvnuu5l8m2qeaj0qap'
+    salesApi.paymentJournals.getAll.mockReturnValueOnce([
+      {
+        id: 'a0e0e5c3-1004-4271-80ba-d05eda3e8220',
+        paymentStatus: 'In Progress',
+        paymentReference,
+        paymentTimestamp: '2020-06-01T10:35:56.873Z'
+      }
+    ])
+    govUkPayApi.fetchPaymentStatus.mockReturnValueOnce({
+      json: async () => ({ state: { status: 'success' } })
+    })
+
+    await execute(1, 1)
+
+    expect(govUkPayApi.fetchPaymentStatus).toHaveBeenCalledWith(paymentReference, false)
+  })
+
+  it('calls fetchPaymentEvents with recurring as true since agreementId exists', async () => {
+    salesApi.retrieveStagedTransaction.mockReturnValueOnce({ recurringPayment: { agreementId: '123' } })
+    const paymentReference = '35nioqikvvnuu5l8m2qeaj0qap'
+    salesApi.paymentJournals.getAll.mockReturnValueOnce([
+      {
+        id: 'a0e0e5c3-1004-4271-80ba-d05eda3e8220',
+        paymentStatus: 'In Progress',
+        paymentReference,
+        paymentTimestamp: '2020-06-01T10:35:56.873Z',
+        agreementId: 'c9267c6e-573d-488b-99ab-ea18431fc472'
+      }
+    ])
+    govUkPayApi.fetchPaymentStatus.mockResolvedValueOnce({
+      json: async () => ({ state: { status: 'success' } })
+    })
+    govUkPayApi.fetchPaymentEvents.mockResolvedValueOnce({
+      json: async () => ({ events: [{ state: { status: 'success' }, updated: '2020-06-01T10:35:56.873Z' }] })
+    })
+
+    await execute(1, 1)
+
+    expect(govUkPayApi.fetchPaymentEvents).toHaveBeenCalledWith(paymentReference, true)
+  })
+
+  it('calls fetchPaymentEvents with recurring as false since agreementId does not exist', async () => {
+    const paymentReference = '45nioqikvvnuu5l8m2qeaj0qap'
+    salesApi.paymentJournals.getAll.mockReturnValueOnce([
+      {
+        id: 'a0e0e5c3-1004-4271-80ba-d05eda3e8220',
+        paymentStatus: 'In Progress',
+        paymentReference,
+        paymentTimestamp: '2020-06-01T10:35:56.873Z'
+      }
+    ])
+    govUkPayApi.fetchPaymentStatus.mockReturnValueOnce({
+      json: async () => ({ state: { status: 'success' } })
+    })
+    govUkPayApi.fetchPaymentEvents.mockReturnValueOnce({
+      json: async () => ({ events: [{ state: { status: 'success' } }] })
+    })
+
+    await execute(1, 1)
+
+    expect(govUkPayApi.fetchPaymentEvents).toHaveBeenCalledWith(paymentReference, false)
+  })
+
+  describe("When a payment isn't present in GovPay", () => {
+    const absentPaymentSetup = () => {
+      const sampleJournalEntries = journalEntries()
+      const NOT_FOUND_ID = sampleJournalEntries[2].id
+      const NOT_FOUND_PAYMENT_REFERENCE = sampleJournalEntries[2].paymentReference
+
+      salesApi.paymentJournals.getAll.mockReturnValueOnce(sampleJournalEntries)
 
-      govUkPayApi.fetchPaymentEvents.mockImplementation(paymentReference => {
+      govUkPayApi.fetchPaymentEvents.mockImplementationOnce(paymentReference => {
         if (paymentReference === NOT_FOUND_PAYMENT_REFERENCE) {
-          return { json: async () => govUkPayStatusNotFound }
+          return { json: async () => govUkPayStatusNotFound() }
         }
         return { json: async () => createPaymentEventsEntry(govUkPayStatusEntries.find(se => se.payment_id === paymentReference)) }
       })
 
       govUkPayApi.fetchPaymentStatus.mockImplementation(paymentReference => {
         if (paymentReference === NOT_FOUND_PAYMENT_REFERENCE) {
-          return { json: async () => govUkPayStatusNotFound }
+          return { json: async () => govUkPayStatusNotFound() }
         }
         return { json: async () => govUkPayStatusEntries.find(se => se.payment_id === paymentReference) }
       })
-    })
 
-    it("When a payment isn't present in GovPay, no error is thrown", async () => {
+      return {
+        sampleJournalEntries,
+        NOT_FOUND_ID
+      }
+    }
+    afterEach(() => govUkPayApi.fetchPaymentStatus.mockClear())
+
+    it('no error is thrown', async () => {
+      absentPaymentSetup()
       await expect(execute(1, 1)).resolves.toBeUndefined()
     })
 
-    it("when a payment isn't present in GovPay, other results process", async () => {
+    it('other results process', async () => {
+      const { NOT_FOUND_ID, sampleJournalEntries } = absentPaymentSetup()
+
       await execute(1, 1)
 
-      const foundIds = journalEntries.map(j => j.id).filter(id => id !== NOT_FOUND_ID)
+      const foundIds = sampleJournalEntries.map(j => j.id).filter(id => id !== NOT_FOUND_ID)
       for (const foundId of foundIds) {
         expect(salesApi.updatePaymentJournal).toHaveBeenCalledWith(foundId, expect.any(Object))
       }
     })
 
-    it("when a payment isn't present in GovPay, it's marked as expired after 3 hours", async () => {
-      const missingJournalEntry = journalEntries.find(je => je.id === NOT_FOUND_ID)
-      missingJournalEntry.paymentTimestamp = moment()
-        .subtract(3, 'hours')
-        .toISOString()
+    it("it's marked as expired after 3 hours", async () => {
+      const { NOT_FOUND_ID, sampleJournalEntries } = absentPaymentSetup()
+      const missingJournalEntry = sampleJournalEntries.find(je => je.id === NOT_FOUND_ID)
+      missingJournalEntry.paymentTimestamp = moment().subtract(3, 'hours').toISOString()
+
       await execute(1, 1)
+
       expect(salesApi.updatePaymentJournal).toHaveBeenCalledWith(
         NOT_FOUND_ID,
         expect.objectContaining({
@@ -211,12 +314,13 @@ describe('processor', () => {
       )
     })
 
-    it("when a payment isn't present in GovPay, it's not marked as expired if 3 hours haven't passed", async () => {
-      const missingJournalEntry = journalEntries.find(je => je.id === NOT_FOUND_ID)
-      missingJournalEntry.paymentTimestamp = moment()
-        .subtract(2, 'hours')
-        .toISOString()
+    it("it's not marked as expired if 3 hours haven't passed", async () => {
+      const { NOT_FOUND_ID, sampleJournalEntries } = absentPaymentSetup()
+      const missingJournalEntry = sampleJournalEntries.find(je => je.id === NOT_FOUND_ID)
+      missingJournalEntry.paymentTimestamp = moment().subtract(2, 'hours').toISOString()
+
       await execute(1, 1)
+
       expect(salesApi.updatePaymentJournal).not.toHaveBeenCalledWith(
         NOT_FOUND_ID,
         expect.objectContaining({
@@ -224,5 +328,87 @@ describe('processor', () => {
         })
       )
     })
+
+    it('cancels the recurring payment when being marked as expired', async () => {
+      const { NOT_FOUND_ID, sampleJournalEntries } = absentPaymentSetup()
+      const rpid = Symbol('rp-id')
+      salesApi.retrieveStagedTransaction.mockImplementation(pjid => {
+        if (pjid === NOT_FOUND_ID) {
+          return {
+            paymentTimestamp: moment().subtract(3, 'hours'),
+            recurringPayment: { agreementId: 'abc-123', id: rpid }
+          }
+        }
+      })
+      const missingJournalEntry = sampleJournalEntries.find(je => je.id === NOT_FOUND_ID)
+      missingJournalEntry.paymentTimestamp = moment().subtract(3, 'hours').toISOString()
+
+      await execute(1, 1)
+
+      expect(salesApi.cancelRecurringPayment).toHaveBeenCalledWith(rpid)
+      salesApi.retrieveStagedTransaction.mockClear()
+    })
+
+    it("doesn't call cancel for payments without a recurring payment", async () => {
+      const { NOT_FOUND_ID, sampleJournalEntries } = absentPaymentSetup()
+      salesApi.retrieveStagedTransaction.mockImplementationOnce(pjid => {
+        if (pjid === NOT_FOUND_ID) {
+          return {
+            paymentTimestamp: moment().subtract(3, 'hours'),
+            recurringPayment: { agreementId: 'abc-123', id: 'def-456' }
+          }
+        }
+      })
+      const missingJournalEntry = sampleJournalEntries.find(je => je.id === NOT_FOUND_ID)
+      missingJournalEntry.paymentTimestamp = moment().subtract(3, 'hours').toISOString()
+
+      await execute(1, 1)
+
+      expect(salesApi.cancelRecurringPayment).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('Recurring Payment is cancelled when', () => {
+    it('payment has an error status', async () => {
+      const id = Symbol('rp-id')
+      salesApi.paymentJournals.getAll.mockReturnValueOnce([journalEntries()[0]])
+      salesApi.retrieveStagedTransaction.mockReturnValueOnce({ recurringPayment: { agreementId: 'abc-123', id } })
+      govUkPayApi.fetchPaymentStatus.mockReturnValueOnce({
+        json: async () => ({ state: { status: PAYMENT_STATUS.Error } })
+      })
+
+      await execute(1, 1)
+
+      expect(salesApi.cancelRecurringPayment).toHaveBeenCalledWith(id)
+    })
+
+    it.each([
+      ['expired', GOVUK_PAY_ERROR_STATUS_CODES.EXPIRED],
+      ['user_cancelled', GOVUK_PAY_ERROR_STATUS_CODES.USER_CANCELLED],
+      ['rejected', GOVUK_PAY_ERROR_STATUS_CODES.REJECTED]
+    ])('payment status code is %s', async (_d, paymentStatus) => {
+      const id = Symbol('rp-id')
+      salesApi.paymentJournals.getAll.mockReturnValueOnce([journalEntries()[0]])
+      salesApi.retrieveStagedTransaction.mockReturnValueOnce({ recurringPayment: { agreementId: 'abc-123', id } })
+      govUkPayApi.fetchPaymentStatus.mockReturnValueOnce({
+        json: async () => ({ state: { code: paymentStatus } })
+      })
+
+      await execute(1, 1)
+
+      expect(salesApi.cancelRecurringPayment).toHaveBeenCalledWith(id)
+    })
+  })
+
+  it("doesn't cancel Recurring Payment if payment succeeded", async () => {
+    salesApi.paymentJournals.getAll.mockReturnValueOnce([journalEntries()[0]])
+    salesApi.retrieveStagedTransaction.mockReturnValueOnce({ recurringPayment: { agreementId: 'abc-123', id: 'def-456' } })
+    govUkPayApi.fetchPaymentStatus.mockReturnValueOnce({
+      json: async () => ({ state: { status: 'success' } })
+    })
+
+    await execute(1, 1)
+
+    expect(salesApi.cancelRecurringPayment).not.toHaveBeenCalled()
   })
 })

package/src/processors/processor.js

@@ -3,9 +3,9 @@ import {
   GOVUK_PAY_ERROR_STATUS_CODES,
   PAYMENT_JOURNAL_STATUS_CODES,
   TRANSACTION_SOURCE,
-  PAYMENT_TYPE
+  PAYMENT_TYPE,
+  PAYMENT_STATUS
 } from '@defra-fish/business-rules-lib'
-
 import Bottleneck from 'bottleneck'
 import moment from 'moment'
 import db from 'debug'
@@ -19,11 +19,58 @@ const limiter = new Bottleneck({
   maxConcurrent: process.env.CONCURRENCY || CONCURRENCY_DEFAULT
 })
 
-const processPaymentResults = async transaction => {
-  if (transaction.paymentStatus.state?.status === 'error') {
-    await salesApi.updatePaymentJournal(transaction.id, { paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.Failed })
+const getPaymentJournalStatusCodeFromTransaction = transaction => {
+  if (transaction.paymentStatus.state?.status === PAYMENT_STATUS.Error) {
+    return PAYMENT_JOURNAL_STATUS_CODES.Failed
+  }
+  if (transaction.paymentStatus.state?.status === PAYMENT_STATUS.Success) {
+    return PAYMENT_JOURNAL_STATUS_CODES.Completed
+  }
+  const govPayErrorStatusCode = transaction.paymentStatus.state?.code || transaction.paymentStatus.code
+  switch (govPayErrorStatusCode) {
+    case GOVUK_PAY_ERROR_STATUS_CODES.EXPIRED:
+    case GOVUK_PAY_ERROR_STATUS_CODES.NOT_FOUND:
+      return PAYMENT_JOURNAL_STATUS_CODES.Expired
+    case GOVUK_PAY_ERROR_STATUS_CODES.USER_CANCELLED:
+      return PAYMENT_JOURNAL_STATUS_CODES.Cancelled
+    case GOVUK_PAY_ERROR_STATUS_CODES.REJECTED:
+      return PAYMENT_JOURNAL_STATUS_CODES.Failed
+  }
+}
+
+const isExpiredCancelledRejectedOrNotFoundAndPastTimeout = transaction => {
+  const { paymentStatus, paymentTimestamp } = transaction
+
+  const isExpiredCancelledOrRejected = [
+    GOVUK_PAY_ERROR_STATUS_CODES.EXPIRED,
+    GOVUK_PAY_ERROR_STATUS_CODES.USER_CANCELLED,
+    GOVUK_PAY_ERROR_STATUS_CODES.REJECTED
+  ].includes(paymentStatus.state?.code)
+
+  // The payment's not found and three hours have elapsed
+  const isNotFoundAndPastTimeout =
+    paymentStatus?.code === GOVUK_PAY_ERROR_STATUS_CODES.NOT_FOUND &&
+    moment().diff(moment(paymentTimestamp), 'hours') >= MISSING_PAYMENT_EXPIRY_TIMEOUT
+
+  return isExpiredCancelledOrRejected || isNotFoundAndPastTimeout
+}
+
+const shouldUpdatePaymentJournal = transaction => {
+  const isSuccessOrError = [PAYMENT_STATUS.Success, PAYMENT_STATUS.Error].includes(transaction.paymentStatus.state?.status)
+
+  return isSuccessOrError || isExpiredCancelledRejectedOrNotFoundAndPastTimeout(transaction)
+}
+
+const shouldCancelRecurringPayment = transaction => {
+  if (transaction.recurringPaymentId) {
+    const isError = transaction.paymentStatus.state?.status === PAYMENT_STATUS.Error
+
+    return isError || isExpiredCancelledRejectedOrNotFoundAndPastTimeout(transaction)
   }
+  return false
+}
 
+const processPaymentResults = async transaction => {
   if (transaction.paymentStatus.state?.status === 'success') {
     debug(`Completing mop up finalization for transaction id: ${transaction.id}`)
     await salesApi.finaliseTransaction(transaction.id, {
@@ -34,38 +81,25 @@ const processPaymentResults = async transaction => {
         method: PAYMENT_TYPE.debit
       }
     })
-    await salesApi.updatePaymentJournal(transaction.id, { paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.Completed })
-  } else {
-    // The payment expired
-    if (transaction.paymentStatus.state?.code === GOVUK_PAY_ERROR_STATUS_CODES.EXPIRED) {
-      await salesApi.updatePaymentJournal(transaction.id, { paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.Expired })
-    }
-
-    // The user cancelled the payment
-    if (transaction.paymentStatus.state?.code === GOVUK_PAY_ERROR_STATUS_CODES.USER_CANCELLED) {
-      await salesApi.updatePaymentJournal(transaction.id, { paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.Cancelled })
-    }
-
-    // The payment was rejected
-    if (transaction.paymentStatus.state?.code === GOVUK_PAY_ERROR_STATUS_CODES.REJECTED) {
-      await salesApi.updatePaymentJournal(transaction.id, { paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.Failed })
-    }
-
-    // The payment's not found and three hours have elapsed
-    if (
-      transaction.paymentStatus.code === GOVUK_PAY_ERROR_STATUS_CODES.NOT_FOUND &&
-      moment().diff(moment(transaction.paymentTimestamp), 'hours') >= MISSING_PAYMENT_EXPIRY_TIMEOUT
-    ) {
-      await salesApi.updatePaymentJournal(transaction.id, { paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.Expired })
-    }
+  }
+
+  if (shouldUpdatePaymentJournal(transaction)) {
+    await salesApi.updatePaymentJournal(transaction.id, {
+      paymentStatus: getPaymentJournalStatusCodeFromTransaction(transaction)
+    })
+  }
+
+  if (shouldCancelRecurringPayment(transaction)) {
+    await salesApi.cancelRecurringPayment(transaction.recurringPaymentId)
   }
 }
 
-const getStatus = async paymentReference => {
-  const paymentStatusResponse = await govUkPayApi.fetchPaymentStatus(paymentReference)
+const getStatus = async (paymentReference, agreementId) => {
+  const recurring = !!agreementId
+  const paymentStatusResponse = await govUkPayApi.fetchPaymentStatus(paymentReference, recurring)
   const paymentStatus = await paymentStatusResponse.json()
   if (paymentStatus.state?.status === 'success') {
-    const eventsResponse = await govUkPayApi.fetchPaymentEvents(paymentReference)
+    const eventsResponse = await govUkPayApi.fetchPaymentEvents(paymentReference, recurring)
     const { events } = await eventsResponse.json()
     paymentStatus.transactionTimestamp = events.find(e => e.state.status === 'success')?.updated
   }
@@ -75,15 +109,11 @@ const getStatus = async paymentReference => {
 const getStatusWrapped = limiter.wrap(getStatus)
 
 export const execute = async (ageMinutes, scanDurationHours) => {
-  debug(
-    `Running payment mop up processor with a payment age of ${ageMinutes} minutes ` + `and a scan duration of ${scanDurationHours} hours`
-  )
+  debug(`Running payment mop up processor with a payment age of ${ageMinutes} minutes and a scan duration of ${scanDurationHours} hours`)
 
   const toTimestamp = moment().add(-1 * ageMinutes, 'minutes')
   const fromTimestamp = toTimestamp.clone().add(-1 * scanDurationHours, 'hours')
 
-  console.log(`Scanning the payment journal for payments created between ${fromTimestamp} and ${toTimestamp}`)
-
   const paymentJournals = await salesApi.paymentJournals.getAll({
     paymentStatus: PAYMENT_JOURNAL_STATUS_CODES.InProgress,
     from: fromTimestamp.toISOString(),
@@ -91,13 +121,20 @@ export const execute = async (ageMinutes, scanDurationHours) => {
   })
 
   // Get the status for each payment from the GOV.UK Pay API.
-  const transactions = await Promise.all(
-    paymentJournals.map(async p => ({
-      ...p,
-      paymentStatus: await getStatusWrapped(p.paymentReference)
-    }))
+  const journalsWithRecurringPaymentIDs = await Promise.all(
+    paymentJournals.map(async p => {
+      const transactionRecord = await salesApi.retrieveStagedTransaction(p.id)
+      const paymentJournalWithStatus = {
+        ...p,
+        paymentStatus: await getStatusWrapped(p.paymentReference, transactionRecord?.recurringPayment?.agreementId)
+      }
+      if (transactionRecord?.recurringPayment) {
+        paymentJournalWithStatus.recurringPaymentId = transactionRecord.recurringPayment.id
+      }
+      return paymentJournalWithStatus
+    })
   )
 
   // Process each result
-  await Promise.all(transactions.map(async t => processPaymentResults(t)))
+  await Promise.all(journalsWithRecurringPaymentIDs.map(async j => processPaymentResults(j)))
 }