@defra-fish/dynamics-lib 1.58.0 → 1.59.0-rc.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/dynamics-lib",
-  "version": "1.58.0",
+  "version": "1.59.0-rc.0",
   "description": "Framework to support integration with dynamics",
   "type": "module",
   "engines": {
@@ -43,5 +43,5 @@
     "simple-oauth2": "^4.3.0",
     "uuid": "^8.3.2"
   },
-  "gitHead": "4d2c2ef1bf3016fa38140a1bd78bf26ba5adb68d"
+  "gitHead": "01bc1d91c4f25234b008dafe06b0525760f9c752"
 }

package/src/queries/__tests__/contact.queries.spec.js

@@ -1,5 +1,7 @@
-import { contactForLicensee } from '../contact.queries.js'
+import { contactForLicensee, contactForLicenseeNoReference } from '../contact.queries.js'
 import { dynamicsClient } from '../../client/dynamics-client.js'
+import { Contact } from '../../entities/contact.entity.js'
+import { PredefinedQuery } from '../predefined-query.js'
 
 jest.mock('dynamics-web-api', () => {
   return jest.fn().mockImplementation(() => {
@@ -97,4 +99,50 @@ describe('Contact Queries', () => {
       })
     })
   })
+
+  describe('contactForLicenseeNoReference', () => {
+    beforeEach(() => {
+      jest.resetAllMocks()
+
+      jest.spyOn(Contact.definition, 'mappings', 'get').mockReturnValue({
+        postcode: { field: 'mock_postcode' },
+        birthDate: { field: 'mock_birthdate' }
+      })
+
+      jest.spyOn(Contact.definition, 'defaultFilter', 'get').mockReturnValue('statecode eq 0')
+    })
+
+    it('should return a predefined query', () => {
+      const result = contactForLicenseeNoReference('03/12/1990', 'AB12 3CD')
+      expect(result).toBeInstanceOf(PredefinedQuery)
+    })
+
+    it('root should return Contact', () => {
+      const result = contactForLicenseeNoReference('03/12/1990', 'AB12 3CD')
+      expect(result._root).toEqual(Contact)
+    })
+
+    it('should use mocked values for mapping postcode and birth date', () => {
+      const result = contactForLicenseeNoReference('03/12/1990', 'AB12 3CD')
+      expect(result._retrieveRequest.filter).toEqual(
+        expect.stringContaining(Contact.definition.mappings.postcode.field),
+        expect.stringContaining(Contact.definition.mappings.birthDate.field)
+      )
+    })
+
+    it.each([
+      ['AB12 3CD', '03/12/1990'],
+      ['EF45 6GH', '05/06/1987'],
+      ['IJ78 9KL', '14/11/1975']
+    ])('should return correct retrieve request when postcode is %s and birth date is %s', (postcode, birthDate) => {
+      const result = contactForLicenseeNoReference(birthDate, postcode)
+
+      expect(result._retrieveRequest).toEqual({
+        collection: 'contacts',
+        expand: [],
+        filter: `mock_postcode eq '${postcode}' and mock_birthdate eq ${birthDate} and statecode eq 0`,
+        select: expect.any(Array)
+      })
+    })
+  })
 })

package/src/queries/__tests__/permission.queries.spec.js

@@ -1,36 +1,41 @@
-import { permissionForLicensee, permissionForFullReferenceNumber } from '../permission.queries.js'
+import { permissionForFullReferenceNumber, permissionForContacts } from '../permission.queries.js'
 
 describe('Permission Queries', () => {
-  describe('permissionForLicensee', () => {
-    it('builds a filter to run a query for a permission with a given licensee date of birth and postcode', async () => {
-      const query = permissionForLicensee('ABC123', '2000-01-01', 'AB12 3CD')
-      expect(query.toRetrieveRequest()).toEqual({
-        collection: 'defra_permissions',
-        expand: expect.arrayContaining([
-          expect.objectContaining({ property: 'defra_ContactId' }),
-          expect.objectContaining({ property: 'defra_PermitId' }),
-          expect.objectContaining({ property: 'defra_defra_permission_defra_concessionproof_PermissionId' })
-        ]),
-        filter:
-          "endswith(defra_name, 'ABC123') and defra_ContactId/defra_postcode eq 'AB12 3CD' and defra_ContactId/birthdate eq 2000-01-01 and statecode eq 0",
-        select: expect.any(Array)
-      })
-    })
+  describe('permissionForFullReferenceNumber', () => {
+    it.each([['ABC123'], ['DEF456'], ['GHI789']])(
+      'builds a filter to run a query for a permission with a full reference number whch is %s',
+      async referenceNumber => {
+        const query = permissionForFullReferenceNumber(referenceNumber)
+        expect(query.toRetrieveRequest()).toEqual({
+          collection: 'defra_permissions',
+          expand: expect.arrayContaining([
+            expect.objectContaining({ property: 'defra_ContactId' }),
+            expect.objectContaining({ property: 'defra_PermitId' }),
+            expect.objectContaining({ property: 'defra_defra_permission_defra_concessionproof_PermissionId' })
+          ]),
+          filter: `defra_name eq '${referenceNumber}' and statecode eq 0`,
+          select: expect.any(Array)
+        })
+      }
+    )
   })
 
-  describe('permissionForFullReferenceNumber', () => {
-    it('builds a filter to run a query for a permission with a full reference number', async () => {
-      const query = permissionForFullReferenceNumber('ABC123')
-      expect(query.toRetrieveRequest()).toEqual({
-        collection: 'defra_permissions',
-        expand: expect.arrayContaining([
-          expect.objectContaining({ property: 'defra_ContactId' }),
-          expect.objectContaining({ property: 'defra_PermitId' }),
-          expect.objectContaining({ property: 'defra_defra_permission_defra_concessionproof_PermissionId' })
-        ]),
-        filter: "defra_name eq 'ABC123' and statecode eq 0",
-        select: expect.any(Array)
-      })
-    })
+  describe('permissionForContacts', () => {
+    it.each([['AB12 3CD'], ['EF45 6GH'], ['IJ78 9KL']])(
+      'builds a filter to run a query for a permission with contact id which is %s',
+      async contactId => {
+        const query = permissionForContacts([contactId])
+        expect(query.toRetrieveRequest()).toEqual({
+          collection: 'defra_permissions',
+          expand: expect.arrayContaining([
+            expect.objectContaining({ property: 'defra_ContactId' }),
+            expect.objectContaining({ property: 'defra_PermitId' }),
+            expect.objectContaining({ property: 'defra_defra_permission_defra_concessionproof_PermissionId' })
+          ]),
+          filter: `(defra_ContactId/contactid eq '${contactId}') and statecode eq 0`,
+          select: expect.any(Array)
+        })
+      }
+    )
   })
 })

package/src/queries/contact.queries.js

@@ -1,4 +1,7 @@
 import { dynamicsClient } from '../client/dynamics-client.js'
+import { Contact } from '../entities/contact.entity.js'
+import { escapeODataStringValue } from '../client/util.js'
+import { PredefinedQuery } from './predefined-query.js'
 
 /**
  * @typedef {Object} ContactByLicenceAndPostcode
@@ -33,3 +36,15 @@ export const contactForLicensee = (permissionReferenceNumberLast6Characters, lic
 
   return dynamicsClient.executeUnboundAction('defra_GetContactByLicenceAndPostcode', request)
 }
+
+export const contactForLicenseeNoReference = (licenseeBirthDate, licenseePostcode) => {
+  const { postcode, birthDate } = Contact.definition.mappings
+  const filter = `${postcode.field} eq '${escapeODataStringValue(licenseePostcode)}' and ${birthDate.field} eq ${licenseeBirthDate} and ${
+    Contact.definition.defaultFilter
+  }`
+  return new PredefinedQuery({
+    root: Contact,
+    filter,
+    expand: []
+  })
+}

package/src/queries/permission.queries.js

@@ -3,36 +3,26 @@ import { Permission } from '../entities/permission.entity.js'
 import { escapeODataStringValue } from '../client/util.js'
 import { ConcessionProof } from '../entities/concession-proof.entity.js'
 
-/**
- * Builds a query to retrieve a permission and related entities for a given reference number and related contact information
- *
- * @param permissionReferenceNumber the reference number of the permission used to perform the lookup
- * @param licenseeBirthDate the birth date of the contact associated with the permission
- * @param licenseePostcode the postcode of the contact associated with the permission
- * @returns {PredefinedQuery}
- */
-export const permissionForLicensee = (permissionReferenceNumber, licenseeBirthDate, licenseePostcode) => {
+export const permissionForFullReferenceNumber = permissionReferenceNumber => {
   const { licensee, permit, concessionProofs } = Permission.definition.relationships
-  let filter = `endswith(${Permission.definition.mappings.referenceNumber.field}, '${escapeODataStringValue(permissionReferenceNumber)}')`
-  filter += ` and ${licensee.property}/${licensee.entity.definition.mappings.postcode.field} eq '${escapeODataStringValue(
-    licenseePostcode
-  )}'`
-  filter += ` and ${licensee.property}/${licensee.entity.definition.mappings.birthDate.field} eq ${licenseeBirthDate}`
-  filter += ` and ${Permission.definition.defaultFilter}`
+  const filter = `${Permission.definition.mappings.referenceNumber.field} eq '${escapeODataStringValue(permissionReferenceNumber)}' and ${
+    Permission.definition.defaultFilter
+  }`
   return new PredefinedQuery({
     root: Permission,
     filter: filter,
-    expand: [licensee, permit, concessionProofs]
+    expand: [licensee, permit, { ...concessionProofs, expand: [ConcessionProof.definition.relationships.concession] }]
   })
 }
 
-export const permissionForFullReferenceNumber = permissionReferenceNumber => {
+export const permissionForContacts = contactIds => {
   const { licensee, permit, concessionProofs } = Permission.definition.relationships
-  let filter = `${Permission.definition.mappings.referenceNumber.field} eq '${escapeODataStringValue(permissionReferenceNumber)}'`
-  filter += ` and ${Permission.definition.defaultFilter}`
+  const formattedContactIds = contactIds.map(id => `defra_ContactId/contactid eq '${id}'`).join(' or ')
+  const filter = `(${formattedContactIds}) and ${Permission.definition.defaultFilter}`
+
   return new PredefinedQuery({
     root: Permission,
     filter: filter,
-    expand: [licensee, permit, { ...concessionProofs, expand: [ConcessionProof.definition.relationships.concession] }]
+    expand: [licensee, permit, concessionProofs]
   })
 }