Determine if licence is 'billed'

app/models/water/billing-batch.model.js

@@ -34,6 +34,14 @@ class BillingBatchModel extends WaterBaseModel {
           from: 'billingBatches.regionId',
           to: 'regions.regionId'
         }
+      },
+      billingInvoices: {
+        relation: Model.HasManyRelation,
+        modelClass: 'billing-invoice.model',
+        join: {
+          from: 'billingBatches.billingBatchId',
+          to: 'billingInvoices.billingBatchId'
+        }
       }
     }
   }

app/models/water/billing-invoice-licence.model.js

@@ -0,0 +1,50 @@
+'use strict'
+
+/**
+ * Model for billingInvoiceLicences
+ * @module BillingInvoiceLicenceModel
+ */
+
+const { Model } = require('objection')
+
+const WaterBaseModel = require('./water-base.model.js')
+
+class BillingInvoiceLicenceModel extends WaterBaseModel {
+  static get tableName () {
+    return 'billingInvoiceLicences'
+  }
+
+  static get idColumn () {
+    return 'billingInvoiceLicenceId'
+  }
+
+  static get translations () {
+    return [
+      { database: 'dateCreated', model: 'createdAt' },
+      { database: 'dateUpdated', model: 'updatedAt' }
+    ]
+  }
+
+  static get relationMappings () {
+    return {
+      billingInvoice: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: 'billing-invoice.model',
+        join: {
+          from: 'billingInvoiceLicences.billingInvoiceId',
+          to: 'billingInvoices.billingInvoiceId'
+        }
+      },
+      licence: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: 'licence.model',
+        join: {
+          from: 'billingInvoiceLicences.licenceId',
+          to: 'licences.licenceId'
+        }
+      }
+    }
+  }
+}
+
+module.exports = BillingInvoiceLicenceModel

app/models/water/billing-invoice.model.js

@@ -0,0 +1,50 @@
+'use strict'
+
+/**
+ * Model for billingInvoices
+ * @module BillingInvoiceModel
+ */
+
+const { Model } = require('objection')
+
+const WaterBaseModel = require('./water-base.model.js')
+
+class BillingInvoiceModel extends WaterBaseModel {
+  static get tableName () {
+    return 'billingInvoices'
+  }
+
+  static get idColumn () {
+    return 'billingInvoiceId'
+  }
+
+  static get translations () {
+    return [
+      { database: 'dateCreated', model: 'createdAt' },
+      { database: 'dateUpdated', model: 'updatedAt' }
+    ]
+  }
+
+  static get relationMappings () {
+    return {
+      billingBatch: {
+        relation: Model.BelongsToOneRelation,
+        modelClass: 'billing-batch.model',
+        join: {
+          from: 'billingInvoices.billingBatchId',
+          to: 'billingBatches.billingBatchId'
+        }
+      },
+      billingInvoiceLicences: {
+        relation: Model.HasManyRelation,
+        modelClass: 'billing-invoice-licence.model',
+        join: {
+          from: 'billingInvoices.billingInvoiceId',
+          to: 'billingInvoiceLicences.billingInvoiceId'
+        }
+      }
+    }
+  }
+}
+
+module.exports = BillingInvoiceModel

app/models/water/licence.model.js

@@ -42,6 +42,14 @@ class LicenceModel extends WaterBaseModel {
           from: 'licences.regionId',
           to: 'regions.regionId'
         }
+      },
+      billingInvoiceLicences: {
+        relation: Model.HasManyRelation,
+        modelClass: 'billing-invoice-licence.model',
+        join: {
+          from: 'licences.licenceId',
+          to: 'billingInvoiceLicences.licenceId'
+        }
       }
     }
   }

app/presenters/check/supplementary-data.presenter.js

@@ -7,9 +7,12 @@
 
 function go (data) {
   const licences = data.licences.map((licence) => {
+    const licenceExistsInBilling = _licenceExistsInBilling(licence.billingInvoiceLicences)
+
     return {
       licenceId: licence.licenceId,
-      licenceRef: licence.licenceRef
+      licenceRef: licence.licenceRef,
+      licenceExistsInBilling
     }
   })
   const chargeVersions = data.chargeVersions
@@ -21,6 +24,18 @@ function go (data) {
   }
 }
 
+function _licenceExistsInBilling (billingInvoiceLicences) {
+  if (billingInvoiceLicences) {
+    for (let i = 0; i < billingInvoiceLicences.length; i++) {
+      if (billingInvoiceLicences[i].billingInvoice) {
+        return true
+      }
+    }
+  }
+
+  return false
+}
+
 module.exports = {
   go
 }

app/services/check/supplementary-data.service.js

@@ -14,7 +14,8 @@ const SupplementaryDataPresenter = require('../../presenters/check/supplementary
 async function go (naldRegionId) {
   const region = await FetchRegionService.go(naldRegionId)
   const billingPeriods = BillingPeriodService.go()
-  const licences = await FetchLicencesService.go(region)
+  const billingPeriodFinancialYearEnding = billingPeriods[0].endDate.getFullYear()
+  const licences = await FetchLicencesService.go(region, billingPeriodFinancialYearEnding)
 
   // We know in the future we will be calculating multiple billing periods and so will have to iterate through each,
   // generating bill runs and reviewing if there is anything to bill. For now, whilst our knowledge of the process

app/services/supplementary-billing/fetch-licences.service.js

@@ -17,19 +17,31 @@ const LicenceModel = require('../../models/water/licence.model.js')
  *
  * @returns {Object[]} Array of matching `LicenceModel`
  */
-async function go (region) {
-  const licences = await _fetch(region)
+async function go (region, billingPeriodFinancialYearEnding) {
+  const licences = await _fetch(region, billingPeriodFinancialYearEnding)
 
   return licences
 }
 
-async function _fetch (region) {
+async function _fetch (region, billingPeriodFinancialYearEnding) {
   const result = await LicenceModel.query()
     .distinctOn('licenceId')
     .innerJoinRelated('chargeVersions')
     .where('regionId', region.regionId)
     .where('includeInSupplementaryBilling', 'yes')
     .where('chargeVersions.scheme', 'sroc')
+    .withGraphFetched('billingInvoiceLicences.billingInvoice')
+    .modifyGraph('billingInvoiceLicences', builder => {
+      builder.select(
+        'billingInvoiceLicenceId'
+      )
+    })
+    .modifyGraph('billingInvoiceLicences.billingInvoice', builder => {
+      builder.select(
+        'financialYearEnding'
+      )
+        .where('financialYearEnding', billingPeriodFinancialYearEnding)
+    })
 
   return result
 }

db/migrations/20230111160155_create-water-billing-invoices.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const tableName = 'billing_invoices'
+
+exports.up = async function (knex) {
+  await knex
+    .schema
+    .withSchema('water')
+    .createTable(tableName, table => {
+      // Primary Key
+      table.uuid('billing_invoice_id').primary().defaultTo(knex.raw('gen_random_uuid()'))
+
+      // Data
+      table.uuid('billing_batch_id')
+      table.integer('financial_year_ending')
+
+      // Legacy timestamps
+      table.timestamp('date_created', { useTz: false }).notNullable().defaultTo(knex.fn.now())
+      table.timestamp('date_updated', { useTz: false }).notNullable().defaultTo(knex.fn.now())
+    })
+}
+
+exports.down = function (knex) {
+  return knex
+    .schema
+    .withSchema('water')
+    .dropTableIfExists(tableName)
+}

db/migrations/20230111160251_create-water-billing-invoice-licences.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const tableName = 'billing_invoice_licences'
+
+exports.up = async function (knex) {
+  await knex
+    .schema
+    .withSchema('water')
+    .createTable(tableName, table => {
+      // Primary Key
+      table.uuid('billing_invoice_licence_id').primary().defaultTo(knex.raw('gen_random_uuid()'))
+
+      // Data
+      table.uuid('billing_invoice_id')
+      table.string('licence_ref')
+      table.uuid('licence_id')
+
+      // Legacy timestamps
+      table.timestamp('date_created', { useTz: false }).notNullable().defaultTo(knex.fn.now())
+      table.timestamp('date_updated', { useTz: false }).notNullable().defaultTo(knex.fn.now())
+    })
+}
+
+exports.down = function (knex) {
+  return knex
+    .schema
+    .withSchema('water')
+    .dropTableIfExists(tableName)
+}

test/models/water/billing-batch.model.test.js

@@ -9,6 +9,8 @@ const { expect } = Code
 
 // Test helpers
 const BillingBatchHelper = require('../../support/helpers/water/billing-batch.helper.js')
+const BillingInvoiceHelper = require('../../support/helpers/water/billing-invoice.helper.js')
+const BillingInvoiceModel = require('../../../app/models/water/billing-invoice.model.js')
 const DatabaseHelper = require('../../support/helpers/database.helper.js')
 const RegionHelper = require('../../support/helpers/water/region.helper.js')
 const RegionModel = require('../../../app/models/water/region.model.js')
@@ -64,5 +66,41 @@ describe('Billing Batch model', () => {
         expect(result.region).to.equal(testRegion)
       })
     })
+
+    describe('when linking to billing invoices', () => {
+      let testBillingInvoices
+
+      beforeEach(async () => {
+        testRecord = await BillingBatchHelper.add()
+        const { billingBatchId } = testRecord
+
+        testBillingInvoices = []
+        for (let i = 0; i < 2; i++) {
+          const billingInvoice = await BillingInvoiceHelper.add({ financialYearEnding: 2023 }, { billingBatchId })
+          testBillingInvoices.push(billingInvoice)
+        }
+      })
+
+      it('can successfully run a related query', async () => {
+        const query = await BillingBatchModel.query()
+          .innerJoinRelated('billingInvoices')
+
+        expect(query).to.exist()
+      })
+
+      it('can eager load the billing invoices', async () => {
+        const result = await BillingBatchModel.query()
+          .findById(testRecord.billingBatchId)
+          .withGraphFetched('billingInvoices')
+
+        expect(result).to.be.instanceOf(BillingBatchModel)
+        expect(result.billingBatchId).to.equal(testRecord.billingBatchId)
+
+        expect(result.billingInvoices).to.be.an.array()
+        expect(result.billingInvoices[0]).to.be.an.instanceOf(BillingInvoiceModel)
+        expect(result.billingInvoices).to.include(testBillingInvoices[0])
+        expect(result.billingInvoices).to.include(testBillingInvoices[1])
+      })
+    })
   })
 })