@defra-fish/pocl-job 1.35.0-rc.8 → 1.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/pocl-job",
-  "version": "1.35.0-rc.8",
+  "version": "1.35.0",
   "description": "Post Office Counter Licence sales processor",
   "type": "module",
   "engines": {
@@ -35,8 +35,8 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@defra-fish/business-rules-lib": "1.35.0-rc.8",
-    "@defra-fish/connectors-lib": "1.35.0-rc.8",
+    "@defra-fish/business-rules-lib": "1.35.0",
+    "@defra-fish/connectors-lib": "1.35.0",
     "commander": "^7.2.0",
     "debug": "^4.3.3",
     "filesize": "^6.4.0",
@@ -46,5 +46,5 @@
     "sax-stream": "^1.3.0",
     "ssh2-sftp-client": "^6.0.1"
   },
-  "gitHead": "53f316d007d53e66ac57c4fbfe421f5c3fe6f2f5"
+  "gitHead": "be7f472adf337fc2e5b16431f2767defcab16d92"
 }

package/src/staging/__tests__/__snapshots__/pocl-validation-errors.spec.js.snap

@@ -14,7 +14,7 @@ Object {
       "issueDate": "2020-01-01T14:00:00Z",
       "licensee": Object {
         "birthDate": "1989-07-01",
-        "country": "GB",
+        "country": "GB-ENG",
         "email": "daniel-ricc@example.couk",
         "firstName": "Daniel",
         "lastName": "Ricciardo",
@@ -55,7 +55,7 @@ Array [
           "issueDate": "2020-01-01T14:00:00Z",
           "licensee": Object {
             "birthDate": "1989-07-01",
-            "country": "GB",
+            "country": "GB-ENG",
             "email": "daniel-ricc@example.couk",
             "firstName": "Daniel",
             "lastName": "Ricciardo",
@@ -123,7 +123,7 @@ Object {
       "issueDate": "2020-01-01T14:00:00Z",
       "licensee": Object {
         "birthDate": "1989-07-01",
-        "country": "GB",
+        "country": "GB-ENG",
         "email": "daniel-ricc@example.couk",
         "firstName": "Daniel",
         "lastName": "Ricciardo",
@@ -164,7 +164,7 @@ Array [
           "issueDate": "2020-01-01T14:00:00Z",
           "licensee": Object {
             "birthDate": "1989-07-01",
-            "country": "GB",
+            "country": "GB-ENG",
             "email": "daniel-ricc@example.couk",
             "firstName": "Daniel",
             "lastName": "Ricciardo",
@@ -216,7 +216,7 @@ Object {
       "issueDate": "2020-01-01T14:00:00Z",
       "licensee": Object {
         "birthDate": "1989-07-01",
-        "country": "GB",
+        "country": "GB-ENG",
         "email": "daniel-ricc@example.co.uk",
         "firstName": "Daniel",
         "lastName": "Ricciardo",
@@ -273,7 +273,7 @@ Array [
           "issueDate": "2020-01-01T14:00:00Z",
           "licensee": Object {
             "birthDate": "1989-07-01",
-            "country": "GB",
+            "country": "GB-ENG",
             "email": "daniel-ricc@example.co.uk",
             "firstName": "Daniel",
             "lastName": "Ricciardo",
@@ -328,7 +328,7 @@ Array [
           "issueDate": "2020-01-01T14:00:00Z",
           "licensee": Object {
             "birthDate": "1989-07-01",
-            "country": "GB",
+            "country": "GB-ENG",
             "email": "daniel-ricc@example.co.uk",
             "firstName": "Daniel",
             "lastName": "Ricciardo",

package/src/staging/__tests__/pocl-validation-errors.spec.js

@@ -4,13 +4,13 @@ import { salesApi } from '@defra-fish/connectors-lib'
 jest.mock('@defra-fish/connectors-lib', () => ({
   salesApi: {
     getPoclValidationErrorsForProcessing: jest.fn(),
-    createTransactions: jest.fn(),
+    createTransactions: jest.fn(() => [{ statusCode: 201, response: { id: 'test-response-id' } }]),
     finaliseTransaction: jest.fn(),
     updatePoclValidationError: jest.fn()
   }
 }))
 
-const getPoclValidationError = () => ({
+const getPoclValidationError = overrides => ({
   id: 'test-pocl-validation-error-id',
   dataSource: { label: 'Post Office Sales' },
   serialNumber: '12345-ABCDE',
@@ -21,7 +21,7 @@ const getPoclValidationError = () => ({
   street: 'Eastmead Lane',
   town: 'Bristol',
   postcode: 'BS9 1HJ',
-  country: 'GB',
+  country: { label: 'GB-ENG' },
   birthDate: '1989-07-01',
   email: 'daniel-ricc@example.co.uk',
   mobilePhone: '07722 123456',
@@ -31,14 +31,17 @@ const getPoclValidationError = () => ({
   postalFulfilment: true,
   concessions: '[{"type":"Blue Badge","referenceNumber":"123456789"}]',
   startDate: '2021-06-15',
+  startDateUnvalidated: '2021-06-15',
   permitId: 'test-permit-id',
   transactionDate: '2020-01-01T14:00:00Z',
   amount: 30,
-  paymentSource: 'Post Office Sales',
+  paymentSource: { label: 'Post Office Sales' },
+  paymentSourceUnvalidated: 'Post Office Sales',
   channelId: '948594',
   methodOfPayment: { label: 'Cash' },
   status: { label: 'Ready for Processing' },
-  transactionFile: 'test-pocl-file.xml'
+  transactionFile: 'test-pocl-file.xml',
+  ...overrides
 })
 
 const getFinalisationError = (status, error) => ({
@@ -59,46 +62,118 @@ describe('pocl-validation-errors', () => {
   })
 
   describe('when no validation errors are returned from Sales Api', () => {
-    let result
-    beforeEach(async () => {
+    beforeAll(() => {
       salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue(null)
-      result = await processPoclValidationErrors()
     })
 
-    it('returns undefined', () => {
-      expect(result).toBe(undefined)
+    it('returns undefined', async () => {
+      const result = await processPoclValidationErrors()
+      expect(result).toBeUndefined()
     })
 
-    it('does not attempt to create transactions', () => {
+    it('does not attempt to create transactions', async () => {
+      await processPoclValidationErrors()
       expect(salesApi.createTransactions).not.toBeCalled()
     })
 
-    it('does not finalise transactions which have failed', () => {
+    it('does not finalise transactions which have failed', async () => {
+      await processPoclValidationErrors()
       expect(salesApi.finaliseTransaction).not.toBeCalled()
     })
   })
 
   describe('processes successfully fixed validation errors', () => {
-    let poclValidationError
-    beforeEach(async () => {
-      poclValidationError = getPoclValidationError()
-      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([poclValidationError])
-      salesApi.createTransactions.mockResolvedValue([{ statusCode: 201, response: { id: 'test-response-id' } }])
+    beforeAll(() => {
+      salesApi.getPoclValidationErrorsForProcessing.mockImplementation(() => [getPoclValidationError()])
+    })
+
+    it('creates transaction in the Sales Api', async () => {
       await processPoclValidationErrors()
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload).toMatchSnapshot()
     })
 
-    it('creates transaction in the Sales Api', () => {
-      const validationError = salesApi.createTransactions.mock.calls[0][0][0]
-      expect(validationError).toMatchSnapshot()
+    it('uses startDate if this is provided', async () => {
+      const startDate = '2023-07-15'
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([getPoclValidationError({ startDate })])
+      await processPoclValidationErrors()
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload.permissions[0].startDate).toBe(startDate)
     })
 
-    it('finalises the transaction in the Sales Api', () => {
-      const record = salesApi.finaliseTransaction.mock.calls[0]
+    it("uses startDateUnvalidated if startDate isn't provided", async () => {
+      const startDateUnvalidated = '2023-07-15'
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([
+        getPoclValidationError({ startDateUnvalidated, startDate: undefined })
+      ])
+      await processPoclValidationErrors()
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload.permissions[0].startDate).toBe(startDateUnvalidated)
+    })
+
+    it('uses country if this is provided', async () => {
+      const country = { label: 'GB-ENG' }
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([getPoclValidationError({ country })])
+      await processPoclValidationErrors()
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload.permissions[0].licensee.country).toBe(country.label)
+    })
+
+    it("uses countryUnvalidated if country isn't provided", async () => {
+      const countryUnvalidated = 'England'
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([
+        getPoclValidationError({ countryUnvalidated, country: undefined })
+      ])
+      await processPoclValidationErrors()
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload.permissions[0].licensee.country).toBe(countryUnvalidated)
+    })
+
+    it('uses paymentSource label if this is provided', async () => {
+      const paymentSource = { label: 'Post Office Sales' }
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([getPoclValidationError({ paymentSource })])
+      await processPoclValidationErrors()
+      const finaliseTransaction = salesApi.finaliseTransaction.mock.calls[0][1]
+      expect(finaliseTransaction.payment.source).toBe(paymentSource.label)
+    })
+
+    it("uses paymentSourceUnvalidated if paymentSource isn't provided", async () => {
+      const paymentSourceUnvalidated = 'Fire Sales'
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([
+        getPoclValidationError({ paymentSourceUnvalidated, paymentSource: undefined })
+      ])
+      await processPoclValidationErrors()
+      const finaliseTransaction = salesApi.finaliseTransaction.mock.calls[0][1]
+      expect(finaliseTransaction.payment.source).toBe(paymentSourceUnvalidated)
+    })
+
+    it('populates the channelId with N/A if not provided', async () => {
+      const error = getPoclValidationError()
+      delete error.channelId
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([error])
+      await processPoclValidationErrors()
+      const finaliseTransaction = salesApi.finaliseTransaction.mock.calls[0][1]
+      expect(finaliseTransaction.payment.channelId).toBe('N/A')
+    })
+
+    it("omits transaction file from payload if one isn't provided", async () => {
+      const error = getPoclValidationError()
+      delete error.transactionFile
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([error])
+      await processPoclValidationErrors()
+      const finaliseTransaction = salesApi.finaliseTransaction.mock.calls[0][1]
+      expect(finaliseTransaction.transactionFile).toBeUndefined()
+    })
+
+    it('finalises the transaction in the Sales Api', async () => {
+      await processPoclValidationErrors()
+      const [record] = salesApi.finaliseTransaction.mock.calls
       expect(record).toMatchSnapshot()
     })
 
-    it('updates POCL validation error record in the Sales Api', () => {
-      const record = salesApi.updatePoclValidationError.mock.calls[0]
+    it('updates POCL validation error record in the Sales Api', async () => {
+      await processPoclValidationErrors()
+      const [record] = salesApi.updatePoclValidationError.mock.calls
       expect(record).toMatchSnapshot()
     })
 
@@ -106,60 +181,197 @@ describe('pocl-validation-errors', () => {
       salesApi.finaliseTransaction.mockRejectedValueOnce(getFinalisationError(410, 'Gone'))
       await processPoclValidationErrors()
 
-      const record = salesApi.updatePoclValidationError.mock.calls[0]
+      const [record] = salesApi.updatePoclValidationError.mock.calls
       expect(record).toMatchSnapshot()
     })
   })
 
   describe('processes failed fixes of validation errors', () => {
-    let poclValidationError
-    beforeEach(async () => {
-      poclValidationError = getPoclValidationError()
-      poclValidationError.email = 'daniel-ricc@example.couk'
-      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([poclValidationError])
-      salesApi.createTransactions.mockResolvedValue([{ statusCode: 422, message: '"permissions[0].licensee.email" must be a valid email' }])
-      await processPoclValidationErrors()
+    beforeEach(() => {
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([getPoclValidationError({ email: 'daniel-ricc@example.couk' })])
+      salesApi.createTransactions.mockResolvedValueOnce([
+        { statusCode: 422, message: '"permissions[0].licensee.email" must be a valid email' }
+      ])
     })
 
-    it('creates transaction in the Sales Api', () => {
-      const validationError = salesApi.createTransactions.mock.calls[0][0][0]
-      expect(validationError).toMatchSnapshot()
+    it('creates transaction in the Sales Api', async () => {
+      await processPoclValidationErrors()
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload).toMatchSnapshot()
     })
 
-    it('does not finalise transactions which have failed', () => {
+    it('does not finalise transactions which have failed', async () => {
+      await processPoclValidationErrors()
       expect(salesApi.finaliseTransaction).not.toBeCalled()
     })
 
-    it('updates POCL validation error record in the Sales Api', () => {
-      const record = salesApi.updatePoclValidationError.mock.calls[0]
+    it('updates POCL validation error record in the Sales Api', async () => {
+      await processPoclValidationErrors()
+      const [record] = salesApi.updatePoclValidationError.mock.calls
       expect(record).toMatchSnapshot()
     })
   })
 
   describe('processes records which failed during finalising', () => {
-    let poclValidationError
-    beforeEach(async () => {
-      poclValidationError = getPoclValidationError()
-      poclValidationError.email = 'daniel-ricc@example.couk'
-      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([poclValidationError])
-      salesApi.createTransactions.mockResolvedValue([{ statusCode: 201, response: { id: 'test-response-id' } }])
+    beforeAll(() => {
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([getPoclValidationError({ email: 'daniel-ricc@example.couk' })])
+    })
+
+    it('creates transaction in the Sales Api', async () => {
       salesApi.finaliseTransaction.mockRejectedValueOnce(getFinalisationError(500, 'Internal server error'))
       await processPoclValidationErrors()
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload).toMatchSnapshot()
     })
 
-    it('creates transaction in the Sales Api', () => {
-      const validationError = salesApi.createTransactions.mock.calls[0][0][0]
-      expect(validationError).toMatchSnapshot()
+    it('attempts to finalise transaction in the Sales Api', async () => {
+      salesApi.finaliseTransaction.mockRejectedValueOnce(getFinalisationError(500, 'Internal server error'))
+      await processPoclValidationErrors()
+      const [record] = salesApi.finaliseTransaction.mock.calls
+      expect(record).toMatchSnapshot()
     })
 
-    it('attempts to finalise transaction in the Sales Api', () => {
-      const record = salesApi.finaliseTransaction.mock.calls[0]
+    it('updates POCL validation error record in the Sales Api', async () => {
+      salesApi.finaliseTransaction.mockRejectedValueOnce(getFinalisationError(500, 'Internal server error'))
+      await processPoclValidationErrors()
+      const [record] = salesApi.updatePoclValidationError.mock.calls
       expect(record).toMatchSnapshot()
     })
+  })
 
-    it('updates POCL validation error record in the Sales Api', () => {
-      const record = salesApi.updatePoclValidationError.mock.calls[0]
-      expect(record).toMatchSnapshot()
+  describe('Create transaction payload datasource', () => {
+    it("is set to 'Postal Order Sales' when payment source is 'Postal Order'", async () => {
+      const poclValidationError = getPoclValidationError({ dataSource: null, paymentSource: { label: 'Postal Order' } })
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([poclValidationError])
+      await processPoclValidationErrors()
+
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload.dataSource).toBe('Postal Order Sales')
+    })
+
+    it("is undefined when payment source is not 'Postal Order'", async () => {
+      const poclValidationError = getPoclValidationError({ dataSource: null, paymentSource: { label: 'Magic beans' } })
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([poclValidationError])
+      await processPoclValidationErrors()
+
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload.dataSource).toBeUndefined()
+    })
+
+    it('is undefined when payment source is null', async () => {
+      const poclValidationError = getPoclValidationError({ dataSource: null, paymentSource: null })
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([poclValidationError])
+      await processPoclValidationErrors()
+
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload.dataSource).toBeUndefined()
+    })
+  })
+
+  describe('Create transaction payload serial number', () => {
+    it("is set to 'Postal Order Sales' when paymentSource is 'Postal Order'", async () => {
+      const poclValidationError = getPoclValidationError({ serialNumber: null, paymentSource: { label: 'Postal Order' } })
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([poclValidationError])
+
+      await processPoclValidationErrors()
+
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload.serialNumber).toBe('Postal Order Sales')
+    })
+
+    it("is undefined if payment source is not 'Postal Order'", async () => {
+      const poclValidationError = getPoclValidationError({ serialNumber: null, paymentSource: { label: 'Magic Beans' } })
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValueOnce([poclValidationError])
+
+      await processPoclValidationErrors()
+
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload.serialNumber).toBeUndefined()
+    })
+
+    it('is undefined if payment source is not set', async () => {
+      const poclValidationError = getPoclValidationError({ serialNumber: null, paymentSource: null })
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([poclValidationError])
+
+      await processPoclValidationErrors()
+
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      expect(createTransactionPayload.serialNumber).toBeUndefined()
+    })
+  })
+
+  describe('Finalise transaction payload payment method', () => {
+    it("is 'Other' if payment source is 'Postal Order'", async () => {
+      const poclValidationError = getPoclValidationError({ methodOfPayment: null, paymentSource: { label: 'Postal Order' } })
+      poclValidationError.methodOfPayment = null
+      poclValidationError.paymentSource = { label: 'Postal Order' }
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([poclValidationError])
+
+      await processPoclValidationErrors()
+
+      const finaliseTransactionPayload = salesApi.finaliseTransaction.mock.calls[0][1]
+      expect(finaliseTransactionPayload.payment.method).toBe('Other')
+    })
+
+    it("is undefined if payment source is not 'Postal Order'", async () => {
+      const poclValidationError = getPoclValidationError({ methodOfPayment: null, paymentSource: { label: 'Magic Beans' } })
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([poclValidationError])
+
+      await processPoclValidationErrors()
+
+      const finaliseTransactionPayload = salesApi.finaliseTransaction.mock.calls[0][1]
+      expect(finaliseTransactionPayload.payment.method).toBeUndefined()
+    })
+
+    it('is undefined if payment source is not set', async () => {
+      const poclValidationError = getPoclValidationError({ methodOfPayment: null, paymentSource: null })
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([poclValidationError])
+
+      await processPoclValidationErrors()
+
+      const finaliseTransactionPayload = salesApi.finaliseTransaction.mock.calls[0][1]
+      expect(finaliseTransactionPayload.payment.method).toBeUndefined()
+    })
+  })
+
+  describe('when a date is not in ISO format', () => {
+    it('converts the issueDate to ISO format without milliseconds', async () => {
+      const poclValidationError = getPoclValidationError()
+      poclValidationError.transactionDate = '01/01/2023'
+
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([poclValidationError])
+      salesApi.createTransactions.mockResolvedValue([{ statusCode: 201, response: { id: 'test-response-id' } }])
+      await processPoclValidationErrors()
+
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      const expectedDate = '2023-01-01T00:00:00Z'
+      expect(createTransactionPayload.permissions[0].issueDate).toBe(expectedDate)
+    })
+
+    it('converts the startDate to ISO format without milliseconds', async () => {
+      const poclValidationError = getPoclValidationError()
+      poclValidationError.startDate = '01/01/2023'
+
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([poclValidationError])
+      salesApi.createTransactions.mockResolvedValue([{ statusCode: 201, response: { id: 'test-response-id' } }])
+      await processPoclValidationErrors()
+
+      const [[[createTransactionPayload]]] = salesApi.createTransactions.mock.calls
+      const expectedDate = '2023-01-01T00:00:00Z'
+      expect(createTransactionPayload.permissions[0].startDate).toBe(expectedDate)
+    })
+
+    it('converts the payment timestamp to ISO format without milliseconds', async () => {
+      const poclValidationError = getPoclValidationError()
+      poclValidationError.transactionDate = '01/01/2023'
+
+      salesApi.getPoclValidationErrorsForProcessing.mockResolvedValue([poclValidationError])
+      salesApi.createTransactions.mockResolvedValue([{ statusCode: 201, response: { id: 'test-response-id' } }])
+      await processPoclValidationErrors()
+
+      const finaliseTransactionPayload = salesApi.finaliseTransaction.mock.calls[0][1]
+      const expectedDate = '2023-01-01T00:00:00Z'
+      expect(finaliseTransactionPayload.payment.timestamp).toBe(expectedDate)
     })
   })
 })

package/src/staging/constants.js

@@ -4,6 +4,9 @@ export const MAX_FINALISE_TRANSACTION_BATCH_SIZE = 10
 export const POST_OFFICE_DATASOURCE = 'Post Office Sales'
 export const DIRECT_DEBIT_DATASOURCE = 'DDE File'
 export const DIRECT_DEBIT_PAYMENTSOURCE = 'Direct Debit'
+export const POSTAL_ORDER_DATASOURCE = 'Postal Order Sales'
+export const POSTAL_ORDER_PAYMENTSOURCE = 'Postal Order'
+export const POSTAL_ORDER_PAYMENTMETHOD = 'Other'
 
 export const FILE_STAGE = {
   Pending: 'Received and Pending',

package/src/staging/pocl-validation-errors.js

@@ -1,4 +1,6 @@
 import { salesApi } from '@defra-fish/connectors-lib'
+import { POSTAL_ORDER_DATASOURCE, POSTAL_ORDER_PAYMENTSOURCE, POSTAL_ORDER_PAYMENTMETHOD } from './constants.js'
+import moment from 'moment'
 import db from 'debug'
 const debug = db('pocl:validation-errors')
 
@@ -6,8 +8,8 @@ const mapRecords = records =>
   records.map(record => ({
     poclValidationErrorId: record.id,
     createTransactionPayload: {
-      dataSource: record.dataSource.label,
-      serialNumber: record.serialNumber,
+      dataSource: backfillDataSource(record),
+      serialNumber: backfillSerialNumber(record),
       permissions: [
         {
           licensee: {
@@ -22,38 +24,88 @@ const mapRecords = records =>
             locality: record.locality,
             town: record.town,
             postcode: record.postcode,
-            country: record.country,
+            country: getCountryValue(record),
             preferredMethodOfConfirmation: record.preferredMethodOfConfirmation.label,
             preferredMethodOfNewsletter: record.preferredMethodOfNewsletter.label,
             preferredMethodOfReminder: record.preferredMethodOfReminder.label,
             postalFulfilment: record.postalFulfilment
           },
-          issueDate: record.transactionDate,
-          startDate: record.startDate,
-          permitId: record.permitId,
+          issueDate: formatDateToShortenedISO(record.transactionDate),
+          startDate: formatDateToShortenedISO(record.startDate || record.startDateUnvalidated),
+          permitId: record.permitId.replace(/(^\{|\}$)/g, '').toLowerCase(),
           ...(record.concessions && { concessions: JSON.parse(record.concessions) })
         }
       ]
     },
     finaliseTransactionPayload: {
-      transactionFile: record.transactionFile,
+      ...(record.transactionFile ? { transactionFile: record.transactionFile } : {}),
       payment: {
-        timestamp: record.transactionDate,
+        timestamp: formatDateToShortenedISO(record.transactionDate),
         amount: record.amount,
-        source: record.paymentSource,
-        channelId: record.channelId,
-        method: record.methodOfPayment.label
+        source: getSourceValue(record),
+        channelId: record.channelId || 'N/A',
+        method: backfillPaymentMethod(record.methodOfPayment, record.paymentSource)
       }
     }
   }))
 
+const backfillDataSource = record => {
+  if (record.dataSource) {
+    return record.dataSource.label
+  } else if (record.paymentSource && record.paymentSource.label === POSTAL_ORDER_PAYMENTSOURCE) {
+    return POSTAL_ORDER_DATASOURCE
+  }
+  return undefined
+}
+
+const backfillSerialNumber = record => {
+  if (record.serialNumber) {
+    return record.serialNumber
+  } else if (record.paymentSource && record.paymentSource.label === POSTAL_ORDER_PAYMENTSOURCE) {
+    return POSTAL_ORDER_DATASOURCE
+  }
+  return undefined
+}
+
+const backfillPaymentMethod = (method, paymentSource) => {
+  if (method) {
+    return method.label
+  } else if (paymentSource && paymentSource.label === POSTAL_ORDER_PAYMENTSOURCE) {
+    return POSTAL_ORDER_PAYMENTMETHOD
+  }
+  return undefined
+}
+
+const getCountryValue = record => {
+  if (record.country && record.country.label) {
+    return record.country.label
+  }
+  return record.countryUnvalidated
+}
+
+const getSourceValue = record => {
+  if (record.paymentSource && record.paymentSource.label) {
+    return record.paymentSource.label
+  }
+  return record.paymentSourceUnvalidated
+}
+
+const formatDateToShortenedISO = date => {
+  const manuallyEnteredDateFormat = /[0-9]{2}\/[0-9]{2}\/[0-9]{4}/
+
+  if (date.match(manuallyEnteredDateFormat)) {
+    return moment(date, 'DD/MM/YYYY').toDate().toISOString().split('.')[0] + 'Z'
+  }
+  return date
+}
+
 /**
  * Calls Sales Api to update Dynamics record
  * @param {Array<Object>} failed
  */
 const processFailed = async failed => {
   for (const { record, result } of failed) {
-    debug('Failed when reprocessing record: %o', record)
+    debug('Failed when reprocessing record: %s', JSON.stringify(record))
     await salesApi.updatePoclValidationError(record.poclValidationErrorId, { ...record, errorMessage: result.message })
   }
 }
@@ -78,26 +130,36 @@ const createTransactions = async records => {
   return { succeeded, failed }
 }
 
+const finaliseTransaction = async rec => {
+  const payment = rec.record.finaliseTransactionPayload.payment
+  const finaliseTransactionPayload = {
+    payment: { method: backfillPaymentMethod(payment.method, payment.paymentSource) },
+    ...rec.record.finaliseTransactionPayload
+  }
+  debug('finalising transaction: %o', finaliseTransactionPayload)
+  return salesApi.finaliseTransaction(rec.result.response.id, finaliseTransactionPayload)
+}
+
+const isFulfilled = result => (result?.status === 'fulfilled' || result?.status?.id === 'FINALISED') === true
+
 const finaliseTransactions = async records => {
   const { succeeded: created, failed } = records
-  const finalisationResults = await Promise.allSettled(
-    created.map(rec => salesApi.finaliseTransaction(rec.result.response.id, rec.record.finaliseTransactionPayload))
-  )
+  const finalisationResults = await Promise.allSettled(created.map(rec => finaliseTransaction(rec)))
 
   const succeeded = []
   created.forEach(({ record }, idx) => {
     const result = finalisationResults[idx]
-    if (result.status === 'fulfilled') {
+    if (isFulfilled(result)) {
       succeeded.push({ record, result: result.value })
-    } else if (result.reason.status === 410) {
+    } else if (result?.reason?.status === 410) {
       /*
         HTTP-410 errors indicate that the record has already been finalised.  This can occur if the process is terminated while finalising records
         (between the API call and the database update.) As the transaction has already been finalised, treat these as successful.  The data for the
         previously finalised record is returned under the data key of the error structure returned by the Sales API
        */
-      succeeded.push({ record, result: result.reason.body.data })
+      succeeded.push({ record, result: result?.reason?.body?.data })
     } else {
-      failed.push({ record, result: result.reason })
+      failed.push({ record, result: result?.reason })
     }
   })