@ministryofjustice/hmpps-digital-prison-reporting-frontend 3.8.0 → 3.8.2

package/dpr/components/async-report-list/utils.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-underscore-dangle */
+const parseurl_1 = __importDefault(require("parseurl"));
 const utils_1 = __importDefault(require("../data-table/utils"));
 const utils_2 = __importDefault(require("../async-columns/utils"));
 const utils_3 = __importDefault(require("../pagination/utils"));
@@ -29,7 +30,7 @@ const initDataSources = ({ req, res, next, asyncReportsStore, dataSources }) =>
     }
 };
 exports.default = {
-    renderReport: async ({ req, res, next, url, asyncReportsStore, dataSources }) => {
+    renderReport: async ({ req, res, next, asyncReportsStore, dataSources }) => {
         const { columns: reqColumns } = req.query;
         const dataPromises = initDataSources({ req, res, next, dataSources, asyncReportsStore });
         let renderData = {};
@@ -43,6 +44,7 @@ exports.default = {
                 const fieldDefinition = definition.variant.specification.fields;
                 const { classification } = definition.variant;
                 const columns = utils_2.default.getColumns(fieldDefinition, reqColumns);
+                const url = (0, parseurl_1.default)(req);
                 const pagination = utils_3.default.getPaginationData(url, count);
                 const actions = utils_4.default.initReportActions(definition.variant, reportStateData);
                 const rows = utils_1.default.mapData(reportData, fieldDefinition, columns.value);

package/dpr/components/async-report-list/utils.ts

@@ -1,4 +1,5 @@
 /* eslint-disable no-underscore-dangle */
+import parseUrl from 'parseurl'
 import DataTableUtils from '../data-table/utils'
 import ColumnUtils from '../async-columns/utils'
 import PaginationUtils from '../pagination/utils'
@@ -31,7 +32,7 @@ const initDataSources = ({ req, res, next, asyncReportsStore, dataSources }: Asy
 }
 
 export default {
-  renderReport: async ({ req, res, next, url, asyncReportsStore, dataSources }: AsyncReportUtilsParams) => {
+  renderReport: async ({ req, res, next, asyncReportsStore, dataSources }: AsyncReportUtilsParams) => {
     const { columns: reqColumns } = req.query
     const dataPromises = initDataSources({ req, res, next, dataSources, asyncReportsStore })
 
@@ -47,6 +48,7 @@ export default {
           const { classification } = definition.variant
 
           const columns = ColumnUtils.getColumns(fieldDefinition, <string[]>reqColumns)
+          const url = parseUrl(req)
           const pagination = PaginationUtils.getPaginationData(url, count)
           const actions = ReportActionsUtils.initReportActions(definition.variant, reportStateData)
           const rows = DataTableUtils.mapData(reportData, fieldDefinition, columns.value)

package/dpr/components/pagination/utils.ts

@@ -1,4 +1,5 @@
-import { Page, UrlData } from './types'
+import { Url } from 'url'
+import { Page } from './types'
 
 const SELECTED_PAGE_PARAM = 'selectedPage'
 const PAGE_SIZE_PARAM = 'pageSize'
@@ -121,7 +122,7 @@ const setPageSizes = (totalRows: number) => {
  * @return {*}
  */
 export default {
-  getPaginationData: (url: UrlData, totalRows: number) => {
+  getPaginationData: (url: Url, totalRows: number) => {
     const { pathname, search } = url
     const { pages, pagesLength } = createPages(pathname, search, totalRows)
     return {

package/dpr/routes/asyncReports.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = __importDefault(require("../components/async-filters/utils"));
+const utils_2 = __importDefault(require("../components/async-report-list/utils"));
+const utils_3 = __importDefault(require("../components/async-polling/utils"));
+function routes({ router, asyncReportsStore, dataSources, }) {
+    // 1 - get filters for the report + make request
+    router.get('/async-reports/:reportId/:variantId/request', async (req, res, next) => {
+        res.render('async-request.njk', {
+            title: 'Request Report',
+            postEndpoint: '/requestReport/',
+            ...(await utils_1.default.renderFilters({ req, res, dataSources, next })),
+        });
+    });
+    // 2 - handle the post request to request the report data
+    router.post('/requestReport/', async (req, res, next) => {
+        const redirectToPollingPage = await utils_1.default.requestReport({
+            req,
+            res,
+            dataSources,
+            asyncReportsStore,
+            next,
+        });
+        if (redirectToPollingPage) {
+            res.redirect(redirectToPollingPage);
+        }
+        res.end();
+    });
+    // 3 - polling the status of the request
+    router.get('/async-reports/:reportId/:variantId/request/:executionId', async (req, res, next) => {
+        res.render('async-polling.njk', {
+            title: 'Report Requested',
+            ...(await utils_3.default.renderPolling({ req, res, dataSources, asyncReportsStore, next })),
+        });
+    });
+    // 3 - load the report data
+    router.get('/async-reports/:reportId/:reportVariantId/request/:tableId/report', async (req, res, next) => {
+        res.render('async-report.njk', {
+            ...(await utils_2.default.renderReport({
+                req,
+                res,
+                dataSources,
+                asyncReportsStore,
+                next,
+            })),
+        });
+    });
+}
+exports.default = routes;

package/dpr/routes/{async-reports/routes.js → asyncReports.ts}

@@ -1,13 +1,22 @@
 /* eslint-disable no-underscore-dangle */
-// eslint-disable-next-line import/no-extraneous-dependencies
-const bodyParser = require('body-parser')
-const AsyncFiltersUtils = require('../../components/async-filters/utils').default
-const AsyncReportListUtils = require('../../components/async-report-list/utils').default
-const AsyncPollingUtils = require('../../components/async-polling/utils').default
+import type { Router } from 'express'
+import AsyncFiltersUtils from '../components/async-filters/utils'
+import AsyncReportListUtils from '../components/async-report-list/utils'
+import AsyncPollingUtils from '../components/async-polling/utils'
+import ReportingClient from '../data/reportingClient'
+import AsyncReportStoreService from '../services/requestedReportsService'
 
-const addAsyncReportingRoutes = ({ app, asyncReportsStore, dataSources }) => {
+export default function routes({
+  router,
+  asyncReportsStore,
+  dataSources,
+}: {
+  router: Router
+  asyncReportsStore: AsyncReportStoreService
+  dataSources: ReportingClient
+}) {
   // 1 - get filters for the report + make request
-  app.get('/async-reports/:reportId/:variantId/request', async (req, res, next) => {
+  router.get('/async-reports/:reportId/:variantId/request', async (req, res, next) => {
     res.render('async-request.njk', {
       title: 'Request Report',
       postEndpoint: '/requestReport/',
@@ -16,8 +25,7 @@ const addAsyncReportingRoutes = ({ app, asyncReportsStore, dataSources }) => {
   })
 
   // 2 - handle the post request to request the report data
-  app.use(bodyParser.json())
-  app.post('/requestReport/', async (req, res, next) => {
+  router.post('/requestReport/', async (req, res, next) => {
     const redirectToPollingPage = await AsyncFiltersUtils.requestReport({
       req,
       res,
@@ -25,12 +33,14 @@ const addAsyncReportingRoutes = ({ app, asyncReportsStore, dataSources }) => {
       asyncReportsStore,
       next,
     })
-    res.redirect(redirectToPollingPage)
+    if (redirectToPollingPage) {
+      res.redirect(redirectToPollingPage)
+    }
     res.end()
   })
 
   // 3 - polling the status of the request
-  app.get('/async-reports/:reportId/:variantId/request/:executionId', async (req, res, next) => {
+  router.get('/async-reports/:reportId/:variantId/request/:executionId', async (req, res, next) => {
     res.render('async-polling.njk', {
       title: 'Report Requested',
       ...(await AsyncPollingUtils.renderPolling({ req, res, dataSources, asyncReportsStore, next })),
@@ -38,18 +48,15 @@ const addAsyncReportingRoutes = ({ app, asyncReportsStore, dataSources }) => {
   })
 
   // 3 - load the report data
-  app.get('/async-reports/:reportId/:reportVariantId/request/:tableId/report', async (req, res, next) => {
+  router.get('/async-reports/:reportId/:reportVariantId/request/:tableId/report', async (req, res, next) => {
     res.render('async-report.njk', {
       ...(await AsyncReportListUtils.renderReport({
         req,
         res,
         dataSources,
         asyncReportsStore,
-        url: req._parsedUrl,
         next,
       })),
     })
   })
 }
-
-module.exports = addAsyncReportingRoutes

package/dpr/services/reportingService.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ReportingService {
+    constructor(reportingClient) {
+        this.reportingClient = reportingClient;
+    }
+    async getCount(resourceName, token, listRequest) {
+        return this.reportingClient.getCount(resourceName, token, listRequest);
+    }
+    async getList(resourceName, token, listRequest) {
+        return this.reportingClient.getList(resourceName, token, listRequest);
+    }
+    async getDefinitions(token, dataProductDefinitionsPath) {
+        return this.reportingClient.getDefinitions(token, dataProductDefinitionsPath);
+    }
+    async requestAsyncReport(token, reportId, variantId, query) {
+        return this.reportingClient.requestAsyncReport(token, reportId, variantId, query);
+    }
+    async getAsyncReport(token, reportId, variantId, tableId, query) {
+        return this.reportingClient.getAsyncReport(token, reportId, variantId, tableId, query);
+    }
+    async getAsyncReportStatus(token, reportId, variantId, executionId) {
+        return this.reportingClient.getAsyncReportStatus(token, reportId, variantId, executionId);
+    }
+    async getAsyncCount(token, tableId) {
+        return this.reportingClient.getAsyncCount(token, tableId);
+    }
+}
+exports.default = ReportingService;

package/dpr/services/reportingService.ts

@@ -0,0 +1,55 @@
+import { components } from '../types/api'
+import type ReportingClient from '../data/reportingClient'
+import ReportQuery from '../types/ReportQuery'
+import Dict = NodeJS.Dict
+
+export default class ReportingService {
+  constructor(private readonly reportingClient: ReportingClient) {}
+
+  async getCount(resourceName: string, token: string, listRequest: ReportQuery): Promise<number> {
+    return this.reportingClient.getCount(resourceName, token, listRequest)
+  }
+
+  async getList(resourceName: string, token: string, listRequest: ReportQuery): Promise<Array<NodeJS.Dict<string>>> {
+    return this.reportingClient.getList(resourceName, token, listRequest)
+  }
+
+  async getDefinitions(
+    token: string,
+    dataProductDefinitionsPath?: string,
+  ): Promise<Array<components['schemas']['ReportDefinitionSummary']>> {
+    return this.reportingClient.getDefinitions(token, dataProductDefinitionsPath)
+  }
+
+  async requestAsyncReport(
+    token: string,
+    reportId: string,
+    variantId: string,
+    query: Record<string, string | boolean | number>,
+  ): Promise<Dict<string>> {
+    return this.reportingClient.requestAsyncReport(token, reportId, variantId, query)
+  }
+
+  async getAsyncReport(
+    token: string,
+    reportId: string,
+    variantId: string,
+    tableId: string,
+    query: Dict<string | number>,
+  ): Promise<Array<Dict<string>>> {
+    return this.reportingClient.getAsyncReport(token, reportId, variantId, tableId, query)
+  }
+
+  async getAsyncReportStatus(
+    token: string,
+    reportId: string,
+    variantId: string,
+    executionId: string,
+  ): Promise<Dict<string>> {
+    return this.reportingClient.getAsyncReportStatus(token, reportId, variantId, executionId)
+  }
+
+  async getAsyncCount(token: string, tableId: string): Promise<number> {
+    return this.reportingClient.getAsyncCount(token, tableId)
+  }
+}

package/dpr/types/AsyncReportUtils.ts

@@ -1,13 +1,11 @@
 import { Response, Request, NextFunction } from 'express'
 import AsyncReportStoreService from '../services/requestedReportsService'
-import ReportingClient from '../data/reportingClient'
-import { UrlData } from '../components/pagination/types'
+import ReportingService from '../services/reportingService'
 
 export interface AsyncReportUtilsParams {
   req?: Request
   res: Response
   next?: NextFunction
-  dataSources?: ReportingClient
+  dataSources?: ReportingService
   asyncReportsStore?: AsyncReportStoreService
-  url?: UrlData
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ministryofjustice/hmpps-digital-prison-reporting-frontend",
   "description": "The Digital Prison Reporting Frontend contains templates and code to help display data effectively in UI applications.",
-  "version": "3.8.0",
+  "version": "3.8.2",
   "main": "dpr/assets/js/all.mjs",
   "sass": "dpr/all.scss",
   "engines": {