allow page blocks of holds (#202)

app/holds/get-holds.js

@@ -1,6 +1,7 @@
 const db = require('../data')
 
-const getHolds = async (open = true) => {
+const getHolds = async (pageProperties, open = true) => {
+ let { pageNumber, pageSize } = pageProperties
  const where = open ? { closed: null } : {}
  const holds = await db.hold.findAll({
  where,
@@ -36,6 +37,16 @@ const getHolds = async (open = true) => {
 
  const mergedResults = [...holds, ...autoHolds]
 
+ if (pageNumber && pageSize) {
+ pageNumber = Number(pageNumber)
+ pageSize = Number(pageSize)
+ if (!isNaN(pageNumber) && !isNaN(pageSize)) {
+ const offset = (pageNumber - 1) * pageSize
+ const paginatedResults = mergedResults.slice(offset, offset + pageSize)
+ return paginatedResults
+ }
+ }
+
  return mergedResults
 }
 

app/server/routes/holds.js

@@ -8,7 +8,10 @@ module.exports = [{
  path: '/payment-holds',
  options: {
  handler: async (request, h) => {
- const paymentHolds = await getHolds(request.query.open)
+ const paymentHolds = await getHolds({
+ pageNumber: request.query.page,
+ pageSize: request.query.pageSize
+ }, request.query.open)
  return h.response({ paymentHolds })
  }
  }

package.json

@@ -1,6 +1,6 @@
 {
  "name": "ffc-pay-processing",
- "version": "2.55.21",
+ "version": "2.55.22",
  "description": "Payment Hub processing service",
  "homepage": "https://github.com/DEFRA/ffc-pay-processing",
  "main": "app/index.js",

test/integration/local/holds/get-holds.test.js

@@ -10,6 +10,9 @@ const db = require('../../../../app/data')
 const { getHolds } = require('../../../../app/holds/get-holds')
 const autoHold = require('../../../mocks/holds/auto-hold')
 
+let pageNumber
+let pageSize
+
 describe('get holds', () => {
  beforeEach(async () => {
  jest.clearAllMocks()
@@ -18,65 +21,100 @@ describe('get holds', () => {
  await db.autoHold.create(autoHold)
  await db.hold.create({ ...hold, holdId: 2, closed: TIMESTAMP })
  await db.autoHold.create({ ...autoHold, autoHoldId: 2, closed: TIMESTAMP })
+ pageSize = undefined
+ pageNumber = undefined
  })
 
  test('should return all holds if open only not requested', async () => {
- const holdsResult = await getHolds(false)
+ const holdsResult = await getHolds({ pageNumber, pageSize }, false)
  expect(holdsResult.length).toBe(4)
  })
 
  test('should return open holds if open only requested', async () => {
- const holdsResult = await getHolds(true)
+ const holdsResult = await getHolds({ pageNumber, pageSize }, true)
  expect(holdsResult.length).toBe(2)
  })
 
  test('should return open holds if no parameters', async () => {
- const holdsResult = await getHolds()
+ const holdsResult = await getHolds({ pageNumber, pageSize })
  expect(holdsResult.length).toBe(2)
  })
 
  test('should return holds with hold id', async () => {
- const holdsResult = await getHolds()
+ const holdsResult = await getHolds({ pageNumber, pageSize })
  expect(holdsResult[0].holdId).toBe(hold.holdId)
  expect(holdsResult[1].holdId).toBe(autoHold.autoHoldId)
  })
 
  test('should return holds with frn', async () => {
- const holdsResult = await getHolds()
+ const holdsResult = await getHolds({ pageNumber, pageSize })
  expect(holdsResult[0].frn).toBe(hold.frn.toString())
  expect(holdsResult[1].frn).toBe(autoHold.frn.toString())
  })
 
  test('should return holds with hold category name', async () => {
- const holdsResult = await getHolds()
+ const holdsResult = await getHolds({ pageNumber, pageSize })
  expect(holdsResult[0].holdCategoryName).toBe(sfiHoldCategory.name)
  expect(holdsResult[1].holdCategoryName).toBe(sfiHoldCategory.name)
  })
 
  test('should return holds with scheme id', async () => {
- const holdsResult = await getHolds()
+ const holdsResult = await getHolds({ pageNumber, pageSize })
  expect(holdsResult[0].holdCategorySchemeId).toBe(sfiHoldCategory.schemeId)
  expect(holdsResult[1].holdCategorySchemeId).toBe(sfiHoldCategory.schemeId)
  })
 
  test('should return holds with scheme name', async () => {
- const holdsResult = await getHolds()
+ const holdsResult = await getHolds({ pageNumber, pageSize })
  expect(holdsResult[0].holdCategorySchemeName).toBe(scheme.name)
  expect(holdsResult[1].holdCategorySchemeName).toBe(scheme.name)
  })
 
  test('should return holds with date added', async () => {
- const holdsResult = await getHolds()
+ const holdsResult = await getHolds({ pageNumber, pageSize })
  expect(holdsResult[0].dateTimeAdded).not.toBeNull()
  expect(holdsResult[1].dateTimeAdded).not.toBeNull()
  })
 
  test('should return holds with date closed', async () => {
- const holdsResult = await getHolds()
+ const holdsResult = await getHolds({ pageNumber, pageSize })
  expect(holdsResult[0].dateTimeClosed).toBeNull()
  expect(holdsResult[1].dateTimeClosed).toBeNull()
  })
 
+ test('should return the correct number of holds with valid page and pageSize', async () => {
+ pageNumber = 1
+ pageSize = 1
+ const holdsResult = await getHolds({ pageNumber, pageSize })
+ expect(holdsResult.length).toBe(1)
+ })
+
+ test('should return the correct subset of holds based on page and pageSize', async () => {
+ pageNumber = 2
+ pageSize = 1
+ const holdsResult = await getHolds({ pageNumber, pageSize })
+ expect(holdsResult[0].holdId).toBe(1)
+ })
+
+ test('should return all holds if page and pageSize are not provided', async () => {
+ const holdsResult = await getHolds({}, false)
+ expect(holdsResult.length).toBe(4)
+ })
+
+ test('should return all holds if page or pageSize are invalid', async () => {
+ pageNumber = 'invalid'
+ pageSize = 'invalid'
+ const holdsResult = await getHolds({ pageNumber, pageSize }, false)
+ expect(holdsResult.length).toBe(4)
+ })
+
+ test('should return an empty array if page exceeds total pages', async () => {
+ pageNumber = 3
+ pageSize = 2
+ const holdsResult = await getHolds({ pageNumber, pageSize })
+ expect(holdsResult.length).toBe(0)
+ })
+
  afterAll(async () => {
  await closeDatabaseConnection()
  })