Create return logs for newly imported licences

app/controllers/check.controller.js

@@ -0,0 +1,36 @@
+'use strict'
+
+/**
+ * Controller for /check endpoints
+ * @module CheckController
+ */
+
+const ProcessLicenceReturnLogsService = require('../services/jobs/return-logs/process-licence-return-logs.service.js')
+
+const redirectStatusCode = 204
+
+/**
+ * A test end point to create return logs for a given licence reference
+ *
+ * @param _request - the hapi request object
+ * @param h - the hapi response object
+ *
+ * @returns {Promise<object>} - A promise that resolves to an HTTP response object with a 204 status code
+ */
+async function returnLogsForLicence (_request, h) {
+  let licenceReference
+
+  if (h.request.payload !== null && h.request.payload.licenceReference) {
+    licenceReference = h.request.payload.licenceReference
+  } else {
+    return h.response().code(404)
+  }
+
+  ProcessLicenceReturnLogsService.go(licenceReference)
+
+  return h.response().code(redirectStatusCode)
+}
+
+module.exports = {
+  returnLogsForLicence
+}

app/lib/dates.lib.js

@@ -5,6 +5,8 @@
  * @module DatesLib
  */
 
+const { returnCycleDates } = require('./static-lookups.lib.js')
+
 const february = 2
 const lastDayOfFebruary = 28
 const lastDayOfFebruaryLeapYear = 29
@@ -35,6 +37,106 @@ function formatStandardDateToISO (date) {
   }
 }
 
+/**
+ * Formate the provided date in ISO format.
+ *
+ * @param {Date} date - a date object to be formatted
+ * @returns {Date} - the date formatted in YYYY-MM-DD.
+ */
+function formatDateObjectToISO (date) {
+  return date.toISOString().split('T')[0]
+}
+
+/**
+ * Get the due date of next provided cycle, either summer or winter and all year, formatted as YYYY-MM-DD
+ *
+ * @param {boolean} summer - true for summer, false for winter and all year.
+ * @returns {string} - the due date of the next cycle as an ISO string.
+ */
+function cycleDueDateAsISO (summer) {
+  return formatDateObjectToISO(cycleDueDate(summer))
+}
+
+/**
+ * Get the due date of next provided cycle, either summer or winter and all year
+ *
+ * @param {boolean} summer - true for summer, false for winter and all year.
+ * @returns {Date} - the due date of the next cycle.
+ */
+function cycleDueDate (summer) {
+  if (summer) {
+    return new Date(new Date().getFullYear() + 1,
+      returnCycleDates.summer.dueDate.month,
+      returnCycleDates.summer.dueDate.day
+    )
+  }
+
+  return new Date(new Date().getFullYear() + 1,
+    returnCycleDates.allYear.dueDate.month,
+    returnCycleDates.allYear.dueDate.day
+  )
+}
+
+/**
+ * Get the end date of next provided cycle, either summer or winter and all year, formatted as YYYY-MM-DD
+ *
+ * @param {boolean} summer - true for summer, false for winter and all year.
+ * @returns {string} - the end date of the next cycle as an ISO string.
+ */
+function cycleEndDateAsISO (summer) {
+  return formatDateObjectToISO(cycleEndDate(summer))
+}
+
+/**
+ * Get the end date of next provided cycle, either summer and winter or all year
+ *
+ * @param {boolean} summer - true for summer, false for winter and all year.
+ * @returns {Date} - the end date of the next cycle.
+ */
+function cycleEndDate (summer) {
+  if (summer) {
+    return new Date(new Date().getFullYear() + 1,
+      returnCycleDates.summer.endDate.month,
+      returnCycleDates.summer.endDate.day
+    )
+  }
+
+  return new Date(new Date().getFullYear() + 1,
+    returnCycleDates.allYear.endDate.month,
+    returnCycleDates.allYear.endDate.day
+  )
+}
+
+/**
+ * Get the start date of next provided cycle, either summer and winter and all year, formatted as YYYY-MM-DD
+ *
+ * @param {boolean} summer - true for summer, false for winter and all year.
+ * @returns {string} - the start date of the next cycle as an ISO string.
+ */
+function cycleStartDateAsISO (summer) {
+  return formatDateObjectToISO(cycleStartDate(summer))
+}
+
+/**
+ * Get the start date of next provided cycle, either summer or winter and all year
+ *
+ * @param {boolean} summer - true for summer, false for winter and all year.
+ * @returns {Date} - the start date of the next cycle.
+ */
+function cycleStartDate (summer) {
+  if (summer) {
+    return new Date(new Date().getFullYear(),
+      returnCycleDates.summer.startDate.month,
+      returnCycleDates.summer.startDate.day
+    )
+  }
+
+  return new Date(new Date().getFullYear(),
+    returnCycleDates.allYear.startDate.month,
+    returnCycleDates.allYear.startDate.day
+  )
+}
+
 /**
  * Check if a date is valid or not by creating a date and checking it gives the time
  *
@@ -104,7 +206,14 @@ function _isLeapYear (year) {
 }
 
 module.exports = {
+  formatDateObjectToISO,
   formatStandardDateToISO,
+  cycleDueDate,
+  cycleDueDateAsISO,
+  cycleEndDate,
+  cycleEndDateAsISO,
+  cycleStartDate,
+  cycleStartDateAsISO,
   isISODateFormat,
   isValidDate
 }

app/lib/static-lookups.lib.js

@@ -23,6 +23,19 @@ const organisationTypes = [
   'publicLimitedCompany'
 ]
 
+const returnCycleDates = {
+  allYear: {
+    dueDate: { day: 28, month: 3 },
+    endDate: { day: 31, month: 2 },
+    startDate: { day: 1, month: 3 }
+  },
+  summer: {
+    dueDate: { day: 28, month: 10 },
+    endDate: { day: 31, month: 9 },
+    startDate: { day: 1, month: 10 }
+  }
+}
+
 const returnRequirementFrequencies = {
   day: 'daily',
   week: 'weekly',
@@ -93,6 +106,7 @@ module.exports = {
   companyTypes,
   contactTypes,
   organisationTypes,
+  returnCycleDates,
   returnRequirementFrequencies,
   returnRequirementReasons,
   naldRegions,

app/plugins/router.plugin.js

@@ -17,6 +17,7 @@ const BillRoutes = require('../routes/bills.routes.js')
 const BillRunRoutes = require('../routes/bill-runs.routes.js')
 const BillRunSetupRoutes = require('../routes/bill-runs-setup.routes.js')
 const BillingAccountRoutes = require('../routes/billing-accounts.routes.js')
+const CheckRoutes = require('../routes/check.routes.js')
 const DataRoutes = require('../routes/data.routes.js')
 const FilterRoutesService = require('../services/plugins/filter-routes.service.js')
 const HealthRoutes = require('../routes/health.routes.js')
@@ -37,6 +38,7 @@ const routes = [
   ...BillRunRoutes,
   ...BillRunSetupRoutes,
   ...BillingAccountRoutes,
+  ...CheckRoutes,
   ...LicenceRoutes,
   ...JobRoutes,
   ...ReturnRequirementRoutes,

app/routes/check.routes.js

@@ -0,0 +1,23 @@
+'use strict'
+
+const CheckController = require('../controllers/check.controller.js')
+
+const routes = [
+  {
+    method: 'POST',
+    path: '/check/licence-return-logs',
+    options: {
+      handler: CheckController.returnLogsForLicence,
+      app: {
+        excludeFromProd: true,
+        plainOutput: true
+      },
+      auth: false,
+      plugins: {
+        crumb: false
+      }
+    }
+  }
+]
+
+module.exports = routes

app/services/import/legacy/process-licence.service.js

@@ -7,6 +7,7 @@
 
 const LicenceStructureValidator = require('../../../validators/import/licence-structure.validator.js')
 const PersistLicenceService = require('../persist-licence.service.js')
+const ProcessLicenceReturnLogsService = require('../../jobs/return-logs/process-licence-return-logs.service.js')
 const TransformCompaniesService = require('./transform-companies.service.js')
 const TransformLicenceService = require('./transform-licence.service.js')
 const TransformLicenceVersionPurposeConditionsService = require('./transform-licence-version-purpose-conditions.service.js')
@@ -44,7 +45,7 @@ async function go (licenceRef) {
     const licenceId = await PersistLicenceService.go(transformedLicence, transformedCompanies)
 
     if (wrlsLicenceId) {
-      // Process mod logs
+      await ProcessLicenceReturnLogsService.go(wrlsLicenceId)
     }
 
     calculateAndLogTimeTaken(startTime, 'Legacy licence import complete', { licenceId, licenceRef })

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

@@ -0,0 +1,126 @@
+'use strict'
+
+/**
+ * Fetches data needed for generating return logs
+ * @module FetchReturnLogsService
+ */
+
+const ReturnLogModel = require('../../../models/return-log.model.js')
+const ReturnRequirementModel = require('../../../models/return-requirement.model.js')
+const ReturnVersionModel = require('../../../models/return-version.model.js')
+
+const { db } = require('../../../../db/db.js')
+const { cycleEndDateAsISO, cycleStartDateAsISO, cycleStartDate } = require('../../../lib/dates.lib.js')
+
+/**
+ * Given the licence reference this service returns the return requirements to be turned into return logs.
+ *
+ * @param {string} licenceReference - if provided only do the return log for that licence
+ *
+ * @returns {Promise<Array>} the array of return log payloads to be created in the database
+ */
+async function go (licenceReference) {
+  return _fetchReturnRequirements(licenceReference)
+}
+
+async function _fetchExternalIds (licenceReference) {
+  const externalIds = await ReturnLogModel.query()
+    .select([db.raw("concat(metadata->'nald'->>'regionCode', ':', return_reference) as externalid")])
+    .where('startDate', '>=', cycleStartDate(false))
+    .where('licenceRef', licenceReference)
+
+  const externalIdsArray = externalIds.map((item) => {
+    return item.externalid
+  })
+
+  return externalIdsArray
+}
+
+async function _fetchReturnRequirements (licenceReference) {
+  // pass in false to ge the all year start and end date to make sure we cover the entire year
+  const _cycleEndDate = cycleEndDateAsISO(false)
+  const _cycleStartDate = cycleStartDateAsISO(false)
+  const externalIds = await _fetchExternalIds(licenceReference)
+
+  return ReturnRequirementModel.query()
+    .whereNotIn('returnRequirements.externalId', externalIds)
+    .whereExists(_whereExistsClause(licenceReference, _cycleStartDate, _cycleEndDate))
+    .withGraphFetched('returnVersion')
+    .modifyGraph('returnVersion', (builder) => {
+      builder.select(['endDate',
+        'id',
+        'startDate',
+        'reason'])
+    })
+    .withGraphFetched('returnVersion.licence')
+    .modifyGraph('returnVersion.licence', (builder) => {
+      builder.select(['expiredDate',
+        'id',
+        'lapsedDate',
+        'licenceRef',
+        'revokedDate',
+        db.raw('regions->>\'historicalAreaCode\' as areacode')])
+    })
+    .withGraphFetched('returnVersion.licence.region')
+    .modifyGraph('returnVersion.licence.region', (builder) => {
+      builder.select(['id', 'naldRegionId'])
+    })
+    .withGraphFetched('returnRequirementPoints')
+    .modifyGraph('returnRequirementPoints', (builder) => {
+      builder.select(['description',
+        'ngr1',
+        'ngr2',
+        'ngr3',
+        'ngr4'])
+    })
+    .withGraphFetched('returnRequirementPurposes.primaryPurpose')
+    .modifyGraph('returnRequirementPurposes.primaryPurpose', (builder) => {
+      builder.select(['legacyId', 'description'])
+    })
+    .withGraphFetched('returnRequirementPurposes.secondaryPurpose')
+    .modifyGraph('returnRequirementPurposes.secondaryPurpose', (builder) => {
+      builder.select(['legacyId', 'description'])
+    })
+    .withGraphFetched('returnRequirementPurposes.purpose')
+    .modifyGraph('returnRequirementPurposes.purpose', (builder) => {
+      builder.select(['legacyId', 'description'])
+    })
+}
+
+function _whereExistsClause (licenceReference, cycleStartDate, cycleEndDate) {
+  const query = ReturnVersionModel.query().select(1)
+
+  query.select(1)
+    .innerJoinRelated('licence')
+    .where('licence.licenceRef', licenceReference)
+    .where('returnVersions.startDate', '<=', cycleEndDate)
+    .where('returnVersions.status', 'current')
+    .where((builder) => {
+      builder
+        .whereNull('returnVersions.endDate')
+        .orWhere('returnVersions.endDate', '>=', cycleStartDate)
+    })
+    .where((builder) => {
+      builder
+        .whereNull('licence.expiredDate')
+        .orWhere('licence.expiredDate', '>=', cycleStartDate)
+    })
+    .where((builder) => {
+      builder
+        .whereNull('licence.lapsedDate')
+        .orWhere('licence.lapsedDate', '>=', cycleStartDate)
+    })
+    .where((builder) => {
+      builder
+        .whereNull('licence.revokedDate')
+        .orWhere('licence.revokedDate', '>=', cycleStartDate)
+    })
+
+  query.whereColumn('returnVersions.id', 'returnRequirements.returnVersionId')
+
+  return query
+}
+
+module.exports = {
+  go
+}