Update the 'points' data solution

app/models/licence-version-purpose-point.model.js

@@ -7,9 +7,9 @@
 
 const { Model } = require('objection')
 
-const BasePointModel = require('./base-point.model.js')
+const BaseModel = require('./base.model.js')
 
-class LicenceVersionPurposePointModel extends BasePointModel {
+class LicenceVersionPurposePointModel extends BaseModel {
   static get tableName () {
     return 'licenceVersionPurposePoints'
   }
@@ -23,6 +23,14 @@ class LicenceVersionPurposePointModel extends BasePointModel {
           from: 'licenceVersionPurposePoints.licenceVersionPurposeId',
           to: 'licenceVersionPurposes.id'
         }
+      },
+      point: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: 'point.model',
+        join: {
+          from: 'licenceVersionPurposePoints.pointId',
+          to: 'points.id'
+        }
       }
     }
   }

app/models/licence-version-purpose.model.js

@@ -32,12 +32,16 @@ class LicenceVersionPurposeModel extends BaseModel {
           to: 'licenceVersionPurposeConditions.licenceVersionPurposeId'
         }
       },
-      licenceVersionPurposePoints: {
-        relation: Model.HasManyRelation,
-        modelClass: 'licence-version-purpose-point.model',
+      points: {
+        relation: Model.ManyToManyRelation,
+        modelClass: 'point.model',
         join: {
           from: 'licenceVersionPurposes.id',
-          to: 'licenceVersionPurposePoints.licenceVersionPurposeId'
+          through: {
+            from: 'licenceVersionPurposePoints.licenceVersionPurposeId',
+            to: 'licenceVersionPurposePoints.pointId'
+          },
+          to: 'points.id'
         }
       },
       primaryPurpose: {
@@ -71,19 +75,21 @@ class LicenceVersionPurposeModel extends BaseModel {
    * Modifiers allow us to reuse logic in queries, eg. select the licence version purpose and all related purposes to
    * determine if the purpose is electricity generation.
    *
+   * ```javascript
    * return LicenceVersionPurposeModel.query()
    *   .findById(licenceVersionPurposeId)
    *   .modify('allPurposes')
+   * ```
    *
    * See {@link https://vincit.github.io/objection.js/recipes/modifiers.html | Modifiers} for more details
+   *
+   * @returns {object}
    */
   static get modifiers () {
     return {
-      /**
-       * allPurposes modifier fetches the purpose plus primary and secondary purposes. Built to support determining if
-       * the overall purpose is electricity generation or spray irrigation with two-part tariff. These are needed to
-       * determine what frequency returns should be collected and reported by the licensee.
-       */
+      // allPurposes modifier fetches the purpose plus primary and secondary purposes. Built to support determining if
+      // the overall purpose is electricity generation or spray irrigation with two-part tariff. These are needed to
+      // determine what frequency returns should be collected and reported by the licensee
       allPurposes (query) {
         query
           .withGraphFetched('purpose')

app/models/base-point.model.js → app/models/point.model.js

@@ -1,15 +1,56 @@
 'use strict'
 
 /**
- * @module BasePointModel
+ * Model for points (water.points)
+ * @module PointModel
  */
 
+const { Model } = require('objection')
+
 const BaseModel = require('./base.model.js')
 
-/**
- * Base class for all 'point' based models, for example, `ReturnRequirementPointModel`
- */
-class BasePointModel extends BaseModel {
+class PointModel extends BaseModel {
+  static get tableName () {
+    return 'points'
+  }
+
+  static get relationMappings () {
+    return {
+      licenceVersionPurposes: {
+        relation: Model.ManyToManyRelation,
+        modelClass: 'licence-version-purpose.model',
+        join: {
+          from: 'points.id',
+          through: {
+            from: 'licenceVersionPurposePoints.pointId',
+            to: 'licenceVersionPurposePoints.licenceVersionPurposeId'
+          },
+          to: 'licenceVersionPurposes.id'
+        }
+      },
+      returnRequirements: {
+        relation: Model.ManyToManyRelation,
+        modelClass: 'return-requirement.model',
+        join: {
+          from: 'points.id',
+          through: {
+            from: 'returnRequirementPoints.pointId',
+            to: 'returnRequirementPoints.returnRequirementId'
+          },
+          to: 'returnRequirements.id'
+        }
+      },
+      source: {
+        relation: Model.HasOneRelation,
+        modelClass: 'source.model',
+        join: {
+          from: 'points.sourceId',
+          to: 'sources.id'
+        }
+      }
+    }
+  }
+
   /**
    * Generate a string that describes this abstraction point
    *
@@ -45,4 +86,4 @@ class BasePointModel extends BaseModel {
   }
 }
 
-module.exports = BasePointModel
+module.exports = PointModel

app/models/return-requirement-point.model.js

@@ -7,15 +7,23 @@
 
 const { Model } = require('objection')
 
-const BasePointModel = require('./base-point.model.js')
+const BaseModel = require('./base.model.js')
 
-class ReturnRequirementPointModel extends BasePointModel {
+class ReturnRequirementPointModel extends BaseModel {
   static get tableName () {
     return 'returnRequirementPoints'
   }
 
   static get relationMappings () {
     return {
+      point: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: 'point.model',
+        join: {
+          from: 'returnRequirementPoints.pointId',
+          to: 'points.id'
+        }
+      },
       returnRequirement: {
         relation: Model.BelongsToOneRelation,
         modelClass: 'return-requirement.model',

app/models/return-requirement.model.js

@@ -16,12 +16,16 @@ class ReturnRequirementModel extends BaseModel {
 
   static get relationMappings () {
     return {
-      returnRequirementPoints: {
-        relation: Model.HasManyRelation,
-        modelClass: 'return-requirement-point.model',
+      points: {
+        relation: Model.ManyToManyRelation,
+        modelClass: 'point.model',
         join: {
           from: 'returnRequirements.id',
-          to: 'returnRequirementPoints.returnRequirementId'
+          through: {
+            from: 'returnRequirementPoints.returnRequirementId',
+            to: 'returnRequirementPoints.pointId'
+          },
+          to: 'points.id'
         }
       },
       returnRequirementPurposes: {

app/models/source.model.js

@@ -0,0 +1,31 @@
+'use strict'
+
+/**
+ * Model for sources (water.sources)
+ * @module SourceModel
+ */
+
+const { Model } = require('objection')
+
+const BaseModel = require('./base.model.js')
+
+class SourceModel extends BaseModel {
+  static get tableName () {
+    return 'sources'
+  }
+
+  static get relationMappings () {
+    return {
+      points: {
+        relation: Model.HasManyRelation,
+        modelClass: 'point.model',
+        join: {
+          from: 'sources.id',
+          to: 'points.sourceId'
+        }
+      }
+    }
+  }
+}
+
+module.exports = SourceModel

app/presenters/return-requirements/check/returns-requirements.presenter.js

@@ -20,16 +20,16 @@ const agreementsExceptionsText = {
  * Formats return requirements data for the `/return-requirements/{sessionId}/check` page
  *
  * @param {object[]} requirements - The existing return requirements in the current session
- * @param {module:LicenceVersionPurposePoint[]} licenceVersionPurposePoints - All licence version purpose points linked
- * to the current licence version
+ * @param {module:PointModel[]} points - All points linked to the licence version purposes linked to the current licence
+ * version
  * @param {string} journey - Whether the setup journey is 'no-returns-required' or 'returns-required'
  *
  * @returns {object} returns requirement data needed by the view template
  */
-function go (requirements, licenceVersionPurposePoints, journey) {
+function go (requirements, points, journey) {
   return {
     returnsRequired: journey === 'returns-required',
-    requirements: _requirements(requirements, licenceVersionPurposePoints)
+    requirements: _requirements(requirements, points)
   }
 }
 
@@ -63,7 +63,7 @@ function _agreementsExceptions (agreementsExceptions) {
     .join(', ') + ', and ' + formattedExceptions[formattedExceptions.length - 1]
 }
 
-function _requirements (requirements, licenceVersionPurposePoints) {
+function _requirements (requirements, points) {
   const completedRequirements = []
 
   for (const [index, requirement] of requirements.entries()) {
@@ -72,7 +72,7 @@ function _requirements (requirements, licenceVersionPurposePoints) {
     // NOTE: We determine a requirement is complete because agreement exceptions is populated and it is the last step in
     // the journey
     if (agreementsExceptions) {
-      completedRequirements.push(_mapRequirement(requirement, index, licenceVersionPurposePoints))
+      completedRequirements.push(_mapRequirement(requirement, index, points))
     }
   }
 
@@ -89,24 +89,24 @@ function _mapPurposes (purposes) {
   })
 }
 
-function _mapRequirement (requirement, index, licenceVersionPurposePoints) {
+function _mapRequirement (requirement, index, points) {
   return {
     abstractionPeriod: _abstractionPeriod(requirement.abstractionPeriod),
     agreementsExceptions: _agreementsExceptions(requirement.agreementsExceptions),
     frequencyCollected: returnRequirementFrequencies[requirement.frequencyCollected],
     frequencyReported: returnRequirementFrequencies[requirement.frequencyReported],
     index,
-    points: _mapPoints(requirement.points, licenceVersionPurposePoints),
+    points: _mapPoints(requirement.points, points),
     purposes: _mapPurposes(requirement.purposes),
     returnsCycle: requirement.returnsCycle === 'summer' ? 'Summer' : 'Winter and all year',
     siteDescription: requirement.siteDescription
   }
 }
 
-function _mapPoints (points, licenceVersionPurposePoints) {
-  return points.map((point) => {
-    const matchedPoint = licenceVersionPurposePoints.find((licenceVersionPurposePoint) => {
-      return licenceVersionPurposePoint.naldPointId.toString() === point
+function _mapPoints (selectedPoints, points) {
+  return selectedPoints.map((selectedPoint) => {
+    const matchedPoint = points.find((point) => {
+      return point.id === selectedPoint
     })
 
     return matchedPoint.$describe()

app/presenters/return-requirements/points.presenter.js

@@ -10,21 +10,21 @@
  *
  * @param {module:SessionModel} session - The returns requirements session instance
  * @param {string} requirementIndex - The index of the requirement being added or changed
- * @param {module:LicenceVersionPurposePoint[]} licenceVersionPurposePoints - All licence version purpose points linked
- * to the current licence version
+ * @param {module:PointModel[]} points - All points linked to the licence version purposes linked to the current licence
+ * version
  *
  * @returns {object} - The data formatted for the view template
  */
-function go (session, requirementIndex, licenceVersionPurposePoints) {
+function go (session, requirementIndex, points) {
   const { id: sessionId, licence, requirements } = session
   const requirement = requirements[requirementIndex]
 
   return {
     backLink: _backLink(session, requirementIndex),
     licenceId: licence.id,
-    licencePoints: _licencePoints(licenceVersionPurposePoints),
+    licencePoints: _licencePoints(points),
     licenceRef: licence.licenceRef,
-    selectedNaldPointIds: requirement?.points ? requirement.points.join(',') : '',
+    selectedPointIds: requirement?.points ? requirement.points.join(',') : '',
     sessionId
   }
 }
@@ -39,12 +39,12 @@ function _backLink (session, requirementIndex) {
   return `/system/return-requirements/${id}/purpose/${requirementIndex}`
 }
 
-function _licencePoints (licenceVersionPurposePoints) {
+function _licencePoints (points) {
   // First extract our points from the data, including generating the descriptions
-  const licencePoints = licenceVersionPurposePoints.map((licenceVersionPurposePoint) => {
+  const licencePoints = points.map((point) => {
     return {
-      naldPointId: licenceVersionPurposePoint.naldPointId.toString(),
-      description: licenceVersionPurposePoint.$describe()
+      id: point.id,
+      description: point.$describe()
     }
   })
 

app/presenters/return-requirements/view.presenter.js

@@ -110,7 +110,7 @@ function _mapRequirement (requirement) {
     agreementsExceptions: _agreementsExceptions(requirement),
     frequencyCollected: returnRequirementFrequencies[requirement.collectionFrequency],
     frequencyReported: returnRequirementFrequencies[requirement.reportingFrequency],
-    points: _points(requirement.returnRequirementPoints),
+    points: _points(requirement.points),
     purposes: _purposes(requirement.returnRequirementPurposes),
     returnReference: requirement.legacyId,
     returnsCycle: requirement.summer === true ? 'Summer' : 'Winter and all year',
@@ -129,9 +129,9 @@ function _purposes (returnRequirementPurposes) {
   })
 }
 
-function _points (returnRequirementPoints) {
-  return returnRequirementPoints.map((returnRequirementPoint) => {
-    return returnRequirementPoint.$describe()
+function _points (points) {
+  return points.map((point) => {
+    return point.$describe()
   })
 }
 

app/services/data/load/load.service.js

@@ -42,6 +42,7 @@ const LicenceVersionPurposePointHelper = require('../../../../test/support/helpe
 const LicenceVersionHelper = require('../../../../test/support/helpers/licence-version.helper.js')
 const LicenceHelper = require('../../../../test/support/helpers/licence.helper.js')
 const ModLogHelper = require('../../../../test/support/helpers/mod-log.helper.js')
+const PointHelper = require('../../../../test/support/helpers/point.helper.js')
 const PermitLicenceHelper = require('../../../../test/support/helpers/permit-licence.helper.js')
 const ReturnLogHelper = require('../../../../test/support/helpers/return-log.helper.js')
 const ReturnRequirementPointHelper = require('../../../../test/support/helpers/return-requirement-point.helper.js')
@@ -101,6 +102,7 @@ const LOAD_HELPERS = {
   licenceVersions: { helper: LicenceVersionHelper, test: true, legacy: { schema: 'water', table: 'licence_versions', id: 'licence_version_id' } },
   licences: { helper: LicenceHelper, test: true, legacy: { schema: 'water', table: 'licences', id: 'licence_id' } },
   modLogs: { helper: ModLogHelper, test: false },
+  points: { helper: PointHelper, test: false },
   permitLicences: { helper: PermitLicenceHelper, test: false },
   returnLogs: { helper: ReturnLogHelper, test: true, legacy: { schema: 'returns', table: 'returns', id: 'return_id' } },
   returnRequirementPoints: { helper: ReturnRequirementPointHelper, test: false },

app/services/jobs/return-logs/fetch-licence-return-requirements.service.js

@@ -65,13 +65,15 @@ async function _fetchReturnRequirements (licenceReference) {
     .modifyGraph('returnVersion.licence.region', (builder) => {
       builder.select(['id', 'naldRegionId'])
     })
-    .withGraphFetched('returnRequirementPoints')
-    .modifyGraph('returnRequirementPoints', (builder) => {
-      builder.select(['description',
-        'ngr1',
-        'ngr2',
-        'ngr3',
-        'ngr4'])
+    .withGraphFetched('points')
+    .modifyGraph('points', (builder) => {
+      builder.select([
+        'points.description',
+        'points.ngr1',
+        'points.ngr2',
+        'points.ngr3',
+        'points.ngr4'
+      ])
     })
     .withGraphFetched('returnRequirementPurposes.primaryPurpose')
     .modifyGraph('returnRequirementPurposes.primaryPurpose', (builder) => {