@defra-fish/recurring-payments-job 1.47.0-rc.1 → 1.47.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/recurring-payments-job",
-  "version": "1.47.0-rc.1",
+  "version": "1.47.0-rc.3",
   "description": "Rod Licensing Recurring Payments Job",
   "type": "module",
   "engines": {
@@ -36,8 +36,10 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@defra-fish/connectors-lib": "1.37.0-rc.2",
-    "commander": "^7.2.0"
+    "@defra-fish/business-rules-lib": "1.47.0-rc.3",
+    "@defra-fish/connectors-lib": "1.47.0-rc.3",
+    "commander": "^7.2.0",
+    "moment-timezone": "^0.5.34"
   },
-  "gitHead": "0230f120b5581a13f9f87ae58d3b7c6317e1d44e"
+  "gitHead": "2c8279cb9e9b4a31af6b595475663a76ecf9204f"
 }

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

@@ -1,8 +1,15 @@
 import { salesApi } from '@defra-fish/connectors-lib'
 import { processRecurringPayments } from '../recurring-payments-processor.js'
 
+jest.mock('@defra-fish/business-rules-lib')
 jest.mock('@defra-fish/connectors-lib', () => ({
-  salesApi: { getDueRecurringPayments: jest.fn() }
+  salesApi: {
+    getDueRecurringPayments: jest.fn(() => []),
+    preparePermissionDataForRenewal: jest.fn(() => ({
+      licensee: { countryCode: 'GB-ENG' }
+    })),
+    createTransaction: jest.fn()
+  }
 }))
 
 describe('recurring-payments-processor', () => {
@@ -40,11 +47,176 @@ describe('recurring-payments-processor', () => {
   it('console log displays "Recurring Payments found: " when env is true', async () => {
     process.env.RUN_RECURRING_PAYMENTS = 'true'
     const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(jest.fn())
-    const rpSymbol = Symbol('rp')
-    salesApi.getDueRecurringPayments.mockReturnValueOnce(rpSymbol)
 
     await processRecurringPayments()
 
-    expect(consoleLogSpy).toHaveBeenCalledWith('Recurring Payments found: ', rpSymbol)
+    expect(consoleLogSpy).toHaveBeenCalledWith('Recurring Payments found: ', [])
+  })
+
+  it('prepares the data for found recurring payments', async () => {
+    process.env.RUN_RECURRING_PAYMENTS = 'true'
+    const referenceNumber = Symbol('reference')
+    salesApi.getDueRecurringPayments.mockReturnValueOnce([{ expanded: { activePermission: { entity: { referenceNumber } } } }])
+
+    await processRecurringPayments()
+
+    expect(salesApi.preparePermissionDataForRenewal).toHaveBeenCalledWith(referenceNumber)
+  })
+
+  it('creates a transaction with the correct data', async () => {
+    process.env.RUN_RECURRING_PAYMENTS = 'true'
+    salesApi.getDueRecurringPayments.mockReturnValueOnce([{ expanded: { activePermission: { entity: { referenceNumber: '1' } } } }])
+
+    const isLicenceForYou = Symbol('isLicenceForYou')
+    const isRenewal = Symbol('isRenewal')
+    const country = Symbol('country')
+    const permitId = Symbol('permitId')
+    const firstName = Symbol('firstName')
+    const lastName = Symbol('lastName')
+
+    salesApi.preparePermissionDataForRenewal.mockReturnValueOnce({
+      isLicenceForYou,
+      isRenewal,
+      licensee: {
+        firstName,
+        lastName,
+        country,
+        countryCode: 'GB-ENG'
+      },
+      licenceStartDate: '2020-01-01',
+      licenceStartTime: 3,
+      permitId
+    })
+
+    const expectedData = {
+      dataSource: 'Recurring Payment',
+      permissions: [
+        {
+          isLicenceForYou,
+          isRenewal,
+          issueDate: null,
+          licensee: {
+            firstName,
+            lastName,
+            country
+          },
+          permitId,
+          startDate: '2020-01-01T03:00:00.000Z'
+        }
+      ]
+    }
+
+    await processRecurringPayments()
+
+    expect(salesApi.createTransaction).toHaveBeenCalledWith(expectedData)
+  })
+
+  it('assigns the correct startDate when licenceStartTime is present', async () => {
+    process.env.RUN_RECURRING_PAYMENTS = 'true'
+    salesApi.getDueRecurringPayments.mockReturnValueOnce([{ expanded: { activePermission: { entity: { referenceNumber: '1' } } } }])
+
+    salesApi.preparePermissionDataForRenewal.mockReturnValueOnce({
+      licensee: { countryCode: 'GB-ENG' },
+      licenceStartDate: '2020-03-14',
+      licenceStartTime: 15
+    })
+
+    await processRecurringPayments()
+
+    expect(salesApi.createTransaction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        permissions: [expect.objectContaining({ startDate: '2020-03-14T15:00:00.000Z' })]
+      })
+    )
+  })
+
+  it('assigns the correct startDate when licenceStartTime is not present', async () => {
+    process.env.RUN_RECURRING_PAYMENTS = 'true'
+    salesApi.getDueRecurringPayments.mockReturnValueOnce([{ expanded: { activePermission: { entity: { referenceNumber: '1' } } } }])
+
+    salesApi.preparePermissionDataForRenewal.mockReturnValueOnce({
+      licensee: { countryCode: 'GB-ENG' },
+      licenceStartDate: '2020-03-14'
+    })
+
+    await processRecurringPayments()
+
+    expect(salesApi.createTransaction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        permissions: [expect.objectContaining({ startDate: '2020-03-14T00:00:00.000Z' })]
+      })
+    )
+  })
+
+  it('raises an error if createTransaction fails', async () => {
+    process.env.RUN_RECURRING_PAYMENTS = 'true'
+    salesApi.getDueRecurringPayments.mockReturnValueOnce([{ expanded: { activePermission: { entity: { referenceNumber: '1' } } } }])
+    const error = 'Wuh-oh!'
+    salesApi.createTransaction.mockImplementationOnce(() => {
+      throw new Error(error)
+    })
+
+    await expect(processRecurringPayments()).rejects.toThrowError(error)
+  })
+
+  describe.each([2, 3, 10])('if there are %d recurring payments', count => {
+    it('prepares the data for each one', async () => {
+      process.env.RUN_RECURRING_PAYMENTS = 'true'
+      const references = []
+      for (let i = 0; i < count; i++) {
+        references.push(Symbol('reference' + i))
+      }
+
+      const mockGetDueRecurringPayments = []
+      references.forEach(reference => {
+        mockGetDueRecurringPayments.push({ expanded: { activePermission: { entity: { referenceNumber: reference } } } })
+      })
+      salesApi.getDueRecurringPayments.mockReturnValueOnce(mockGetDueRecurringPayments)
+
+      const expectedData = []
+      references.forEach(reference => {
+        expectedData.push([reference])
+      })
+
+      await processRecurringPayments()
+
+      expect(salesApi.preparePermissionDataForRenewal.mock.calls).toEqual(expectedData)
+    })
+
+    it('creates a transaction for each one', async () => {
+      process.env.RUN_RECURRING_PAYMENTS = 'true'
+
+      const mockGetDueRecurringPayments = []
+      for (let i = 0; i < count; i++) {
+        mockGetDueRecurringPayments.push({ expanded: { activePermission: { entity: { referenceNumber: i } } } })
+      }
+      salesApi.getDueRecurringPayments.mockReturnValueOnce(mockGetDueRecurringPayments)
+
+      const permits = []
+      for (let i = 0; i < count; i++) {
+        permits.push(Symbol('permit' + i))
+      }
+
+      permits.forEach(permit => {
+        salesApi.preparePermissionDataForRenewal.mockReturnValueOnce({
+          licensee: { countryCode: 'GB-ENG' },
+          permitId: permit
+        })
+      })
+
+      const expectedData = []
+      permits.forEach(permit => {
+        expectedData.push([
+          {
+            dataSource: 'Recurring Payment',
+            permissions: [expect.objectContaining({ permitId: permit })]
+          }
+        ])
+      })
+
+      await processRecurringPayments()
+
+      expect(salesApi.createTransaction.mock.calls).toEqual(expectedData)
+    })
   })
 })

package/src/recurring-payments-processor.js

@@ -1,3 +1,5 @@
+import moment from 'moment-timezone'
+import { SERVICE_LOCAL_TIME } from '@defra-fish/business-rules-lib'
 import { salesApi } from '@defra-fish/connectors-lib'
 
 export const processRecurringPayments = async () => {
@@ -6,7 +8,48 @@ export const processRecurringPayments = async () => {
     const date = new Date().toISOString().split('T')[0]
     const response = await salesApi.getDueRecurringPayments(date)
     console.log('Recurring Payments found: ', response)
+    await Promise.all(response.map(record => processRecurringPayment(record)))
   } else {
     console.log('Recurring Payments job disabled')
   }
 }
+
+const processRecurringPayment = async record => {
+  const referenceNumber = record.expanded.activePermission.entity.referenceNumber
+  const transactionData = await processPermissionData(referenceNumber)
+  console.log('Creating new transaction based on', referenceNumber)
+  try {
+    const response = await salesApi.createTransaction(transactionData)
+    console.log('New transaction created:', response)
+  } catch (e) {
+    console.log('Error creating transaction', JSON.stringify(transactionData))
+    throw e
+  }
+}
+
+const processPermissionData = async referenceNumber => {
+  console.log('Preparing data based on', referenceNumber)
+  const data = await salesApi.preparePermissionDataForRenewal(referenceNumber)
+  const licenseeWithoutCountryCode = Object.assign((({ countryCode: _countryCode, ...l }) => l)(data.licensee))
+  return {
+    dataSource: 'Recurring Payment',
+    permissions: [
+      {
+        isLicenceForYou: data.isLicenceForYou,
+        isRenewal: data.isRenewal,
+        issueDate: null,
+        licensee: licenseeWithoutCountryCode,
+        permitId: data.permitId,
+        startDate: prepareStartDate(data)
+      }
+    ]
+  }
+}
+
+const prepareStartDate = permission => {
+  return moment
+    .tz(permission.licenceStartDate, 'YYYY-MM-DD', SERVICE_LOCAL_TIME)
+    .add(permission.licenceStartTime ?? 0, 'hours')
+    .utc()
+    .toISOString()
+}