@defra-fish/dynamics-lib 1.76.0 → 1.77.0-rc.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defra-fish/dynamics-lib",
-  "version": "1.76.0",
+  "version": "1.77.0-rc.10",
   "description": "Framework to support integration with dynamics",
   "type": "module",
   "engines": {
@@ -43,5 +43,5 @@
     "simple-oauth2": "4.3.0",
     "uuid": "8.3.2"
   },
-  "gitHead": "2287ca0defd4b61d66cbea6f0df84568265b036f"
+  "gitHead": "b41c703037390290c9403cafc2e0252ef63e149e"
 }

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

@@ -1,7 +1,8 @@
-import { contactAndPermissionForLicensee, contactForLicenseeNoReference } from '../contact.queries.js'
+import { contactAndPermissionForLicensee, contactForLicenseeNoReference, contactForLicenseeByPersonalDetails } from '../contact.queries.js'
 import { Contact } from '../../entities/contact.entity.js'
 import { Permission } from '../../entities/permission.entity.js'
 import { PredefinedQuery } from '../predefined-query.js'
+import { escapeODataStringValue } from '../../client/util.js'
 
 jest.mock('dynamics-web-api', () => {
   return {
@@ -13,17 +14,21 @@ jest.mock('dynamics-web-api', () => {
   }
 })
 
+jest.mock('../../client/util.js', () => ({
+  escapeODataStringValue: jest.fn(value => value)
+}))
+
 describe('Contact Queries', () => {
   describe('contactForLicenseeNoReference', () => {
     beforeEach(() => {
-      jest.resetAllMocks()
+      const defaultFilter = 'statecode eq 77'
 
       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')
+      jest.spyOn(Contact.definition, 'defaultFilter', 'get').mockReturnValue(defaultFilter)
     })
 
     it('should return a predefined query', () => {
@@ -36,14 +41,6 @@ describe('Contact Queries', () => {
       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'],
@@ -54,7 +51,7 @@ describe('Contact Queries', () => {
       expect(result._retrieveRequest).toEqual({
         collection: 'contacts',
         expand: [],
-        filter: `mock_postcode eq '${postcode}' and mock_birthdate eq ${birthDate} and statecode eq 0`,
+        filter: `mock_postcode eq '${postcode}' and mock_birthdate eq ${birthDate} and ${Contact.definition.defaultFilter}`,
         select: expect.any(Array)
       })
     })
@@ -62,12 +59,13 @@ describe('Contact Queries', () => {
 
   describe('contactAndPermissionForLicensee', () => {
     beforeEach(() => {
-      jest.resetAllMocks()
+      const defaultFilter = 'statecode eq 77'
 
       jest.spyOn(Contact.definition, 'mappings', 'get').mockReturnValue({
         id: { field: 'contactid' },
         postcode: { field: 'defra_postcode' }
       })
+      jest.spyOn(Permission.definition, 'defaultFilter', 'get').mockReturnValue(defaultFilter)
     })
 
     it('should return a predefined query', () => {
@@ -84,7 +82,7 @@ describe('Contact Queries', () => {
       const result = contactAndPermissionForLicensee('ABC123', 'AB12 3CD')
 
       expect(result._retrieveRequest.filter).toEqual(
-        "endswith(defra_name, 'ABC123') and statecode eq 0 and defra_ContactId/defra_postcode eq 'AB12 3CD'"
+        `endswith(defra_name, 'ABC123') and ${Permission.definition.defaultFilter} and defra_ContactId/defra_postcode eq 'AB12 3CD'`
       )
     })
 
@@ -116,7 +114,7 @@ describe('Contact Queries', () => {
 
         expect(result._retrieveRequest).toEqual({
           collection: 'defra_permissions',
-          filter: `endswith(defra_name, '${permissionLast6}') and statecode eq 0 and defra_ContactId/defra_postcode eq '${postcode}'`,
+          filter: `endswith(defra_name, '${permissionLast6}') and ${Permission.definition.defaultFilter} and defra_ContactId/defra_postcode eq '${postcode}'`,
           orderBy: ['defra_issuedate desc', 'defra_ContactId/contactid asc'],
           expand: [
             {
@@ -141,3 +139,84 @@ describe('Contact Queries', () => {
     )
   })
 })
+
+describe('contactForLicenseeByPersonalDetails', () => {
+  beforeEach(() => {
+    const defaultFilter = 'statecode eq 77'
+
+    jest.spyOn(Contact.definition, 'mappings', 'get').mockReturnValue({
+      firstName: { field: 'mock_firstname' },
+      lastName: { field: 'mock_lastname' },
+      premises: { field: 'mock_premises' },
+      postcode: { field: 'mock_postcode' },
+      birthDate: { field: 'mock_birthdate' }
+    })
+
+    jest.spyOn(Contact.definition, 'defaultFilter', 'get').mockReturnValue(defaultFilter)
+  })
+
+  it.each([
+    { details: { licenseeFirstName: 'Brenin' }, testfield: 'first name', fieldName: 'licenseeFirstName' },
+    { details: { licenseeLastName: 'Pysgotwr' }, testfield: 'last name', fieldName: 'licenseeLastName' },
+    { details: { licenseePremises: 'Dunmanifestin' }, testfield: 'premises', fieldName: 'licenseePremises' },
+    { details: { licenseePostcode: 'GZ1 1UH' }, testfield: 'post code', fieldName: 'licenseePostcode' }
+  ])('escapes value of $testfield', ({ testfield: _t, details, fieldName }) => {
+    for (let x = 0; x < 4; x++) {
+      escapeODataStringValue.mockImplementationOnce(value => `!@£${value}$%%`)
+    }
+    const query = contactForLicenseeByPersonalDetails({
+      licenseeFirstName: 'firstName',
+      licenseeLastName: 'lastName',
+      licenseePremises: '15',
+      licenseePostcode: 'AB1 1AB',
+      licenseeBirthDate: '2000-01-01',
+      ...details
+    })
+
+    expect(query._retrieveRequest.filter).toEqual(expect.stringContaining(`!@£${details[fieldName]}$%%`))
+  })
+
+  it.each([
+    ['Smeagol', 'Ring', '2000-10-03', '12', 'AB12 3CD'],
+    ['Frodo', 'Baggins', '1993-09-22', 'Dunmanifestin', 'EF45 6GH'],
+    ['Samwise', 'Gamgee', '1998-03-06', '1507', 'IJ78 9KL']
+  ])(
+    'should return correct retrieve request when first name is %s, last name is %s, birth date is %s, premises is %s and postcode is %s',
+    (licenseeFirstName, licenseeLastName, licenseeBirthDate, licenseePremises, licenseePostcode) => {
+      const result = contactForLicenseeByPersonalDetails({
+        licenseeFirstName,
+        licenseeLastName,
+        licenseeBirthDate,
+        licenseePremises,
+        licenseePostcode
+      })
+
+      expect(result._retrieveRequest).toEqual({
+        collection: 'contacts',
+        expand: [],
+        filter: `mock_firstname eq '${licenseeFirstName}' and mock_lastname eq '${licenseeLastName}' and mock_premises eq '${licenseePremises}' and mock_postcode eq '${licenseePostcode}' and mock_birthdate eq ${licenseeBirthDate} and ${Contact.definition.defaultFilter}`,
+        select: expect.any(Array)
+      })
+    }
+  )
+
+  it('should return a predefined query', () => {
+    const result = contactForLicenseeByPersonalDetails({
+      licenseeFirstName: 'Gandalf',
+      licenseeLastName: 'Grey',
+      licenseeBirthDate: '1960-10-03',
+      licenseePostcode: 'AB12 3CD'
+    })
+    expect(result).toBeInstanceOf(PredefinedQuery)
+  })
+
+  it('root should return Contact', () => {
+    const result = contactForLicenseeByPersonalDetails({
+      licenseeFirstName: 'Aragorn',
+      licenseeLastName: 'Elessar',
+      licenseeBirthDate: '1989-04-20',
+      licenseePostcode: 'AB12 3CD'
+    })
+    expect(result._root).toEqual(Contact)
+  })
+})

package/src/queries/contact.queries.js

@@ -48,3 +48,33 @@ export const contactAndPermissionForLicensee = (permissionLast6Characters, licen
 
   return query
 }
+
+/**
+ * Gets the query to find a contact using their name, postcode and date of birth
+ *
+ * @param {string} licenseeFirstName
+ * @param {string} licenseeLastName
+ * @param {string} licenseeBirthDate
+ * @param {string} licenseePremises
+ * @param {string} licenseePostcode
+ * @returns {PredefinedQuery<Contact>}
+ */
+export const contactForLicenseeByPersonalDetails = ({
+  licenseeFirstName,
+  licenseeLastName,
+  licenseeBirthDate,
+  licenseePremises,
+  licenseePostcode
+}) => {
+  const { firstName, lastName, premises, postcode, birthDate } = Contact.definition.mappings
+  const filter = `${firstName.field} eq '${escapeODataStringValue(licenseeFirstName)}' and ${lastName.field} eq '${escapeODataStringValue(
+    licenseeLastName
+  )}' and ${premises.field} eq '${escapeODataStringValue(licenseePremises)}' and ${postcode.field} eq '${escapeODataStringValue(
+    licenseePostcode
+  )}' and ${birthDate.field} eq ${licenseeBirthDate} and ${Contact.definition.defaultFilter}`
+  return new PredefinedQuery({
+    root: Contact,
+    filter,
+    expand: []
+  })
+}