@ministryofjustice/hmpps-digital-prison-reporting-frontend 3.10.2 → 3.10.3

package/dpr/components/async-filters/utils.js

@@ -136,4 +136,19 @@ exports.default = {
         }
         return redirect;
     },
+    handleError: (error, req) => {
+        const filters = Object.keys(req.body)
+            .filter((attr) => attr.includes('filters.'))
+            .filter((attr) => !!req.body[attr])
+            .map((attr) => {
+            return { name: attr, value: req.body[attr] };
+        });
+        return {
+            title: 'Request Failed',
+            description: 'Your report has failed to generate. The issue has been reported to admin staff',
+            retry: true,
+            error: error.data,
+            filters,
+        };
+    },
 };

package/dpr/components/async-filters/utils.ts

@@ -1,3 +1,4 @@
+import { Request } from 'express'
 import Dict = NodeJS.Dict
 import { components } from '../../types/api'
 import FilterUtils from '../filters/utils'
@@ -161,4 +162,20 @@ export default {
 
     return redirect
   },
+
+  handleError: (error: Dict<string>, req: Request) => {
+    const filters = Object.keys(req.body)
+      .filter((attr) => attr.includes('filters.'))
+      .filter((attr) => !!req.body[attr])
+      .map((attr) => {
+        return { name: attr, value: req.body[attr] }
+      })
+    return {
+      title: 'Request Failed',
+      description: 'Your report has failed to generate. The issue has been reported to admin staff',
+      retry: true,
+      error: error.data,
+      filters,
+    }
+  },
 }

package/dpr/components/async-polling/utils.js

@@ -17,6 +17,8 @@ const getStatus = async (token, reportId, variantId, executionId, currentStatus,
         errorMessage = data.userMessage;
         status = currentStatus === AsyncReport_1.RequestStatus.FINISHED ? AsyncReport_1.RequestStatus.EXPIRED : AsyncReport_1.RequestStatus.FAILED;
     }
+    if (typeof status === 'number')
+        status = AsyncReport_1.RequestStatus.FAILED;
     const res = {
         status,
         ...(errorMessage && { errorMessage }),
@@ -42,43 +44,37 @@ exports.default = {
     getStatus,
     renderPolling: async ({ req, res, dataSources, asyncReportsStore, next }) => {
         var _a;
-        try {
-            const { token } = res.locals.user || 'token';
-            const { reportId, variantId, executionId } = req.params;
-            let reportData = await asyncReportsStore.getReportByExecutionId(executionId);
-            let statusResponse;
-            if ((0, exports.timeoutRequest)(reportData.timestamp.requested)) {
-                statusResponse = {
-                    status: AsyncReport_1.RequestStatus.FAILED,
-                    errorMessage: 'Request taking too long. Request Halted',
-                };
-            }
-            else {
-                statusResponse = await getStatus(token, reportId, variantId, executionId, reportData.status, dataSources, asyncReportsStore, reportData.dataProductDefinitionsPath);
-            }
-            const { status, errorMessage } = statusResponse;
-            if (statusResponse.reportData)
-                reportData = statusResponse.reportData;
-            return {
-                pollingRenderData: {
-                    reportName: reportData.reportName,
-                    variantName: reportData.name,
-                    variantDescription: reportData.description,
-                    executionId,
-                    reportId,
-                    variantId,
-                    status,
-                    tableId: reportData.tableId,
-                    querySummary: reportData.query.summary,
-                    ...(((_a = reportData.url.report) === null || _a === void 0 ? void 0 : _a.fullUrl) && { reportUrl: reportData.url.report.fullUrl }),
-                    ...(reportData.url.request.fullUrl && { requestUrl: reportData.url.request.fullUrl }),
-                    ...(errorMessage && { errorMessage }),
-                },
+        const { token } = res.locals.user || 'token';
+        const { reportId, variantId, executionId } = req.params;
+        let reportData = await asyncReportsStore.getReportByExecutionId(executionId);
+        let statusResponse;
+        if ((0, exports.timeoutRequest)(reportData.timestamp.requested)) {
+            statusResponse = {
+                status: AsyncReport_1.RequestStatus.FAILED,
+                errorMessage: 'Request taking too long. Request Halted',
             };
         }
-        catch (error) {
-            next(error);
-            return false;
+        else {
+            statusResponse = await getStatus(token, reportId, variantId, executionId, reportData.status, dataSources, asyncReportsStore, reportData.dataProductDefinitionsPath);
         }
+        const { status, errorMessage } = statusResponse;
+        if (statusResponse.reportData)
+            reportData = statusResponse.reportData;
+        return {
+            pollingRenderData: {
+                reportName: reportData.reportName,
+                variantName: reportData.name,
+                variantDescription: reportData.description,
+                executionId,
+                reportId,
+                variantId,
+                status,
+                tableId: reportData.tableId,
+                querySummary: reportData.query.summary,
+                ...(((_a = reportData.url.report) === null || _a === void 0 ? void 0 : _a.fullUrl) && { reportUrl: reportData.url.report.fullUrl }),
+                ...(reportData.url.request.fullUrl && { requestUrl: reportData.url.request.fullUrl }),
+                ...(errorMessage && { errorMessage }),
+            },
+        };
     },
 };

package/dpr/components/async-polling/utils.ts

@@ -35,6 +35,7 @@ const getStatus = async (
     status = currentStatus === RequestStatus.FINISHED ? RequestStatus.EXPIRED : RequestStatus.FAILED
   }
 
+  if (typeof status === 'number') status = RequestStatus.FAILED
   const res: GetStatusUtilsResponse = {
     status,
     ...(errorMessage && { errorMessage }),
@@ -57,7 +58,6 @@ export const timeoutRequest = (requestTime: Date) => {
   const diffMins = Math.round(((diffMs % 86400000) % 3600000) / 60000)
   return diffMins >= TIMEOUT_MINS_MAX
 }
-
 interface GetStatusUtilsResponse {
   status: RequestStatus
   errorMessage: string
@@ -67,51 +67,46 @@ interface GetStatusUtilsResponse {
 export default {
   getStatus,
   renderPolling: async ({ req, res, dataSources, asyncReportsStore, next }: AsyncReportUtilsParams) => {
-    try {
-      const { token } = res.locals.user || 'token'
-      const { reportId, variantId, executionId } = req.params
-      let reportData = await asyncReportsStore.getReportByExecutionId(executionId)
+    const { token } = res.locals.user || 'token'
+    const { reportId, variantId, executionId } = req.params
+    let reportData = await asyncReportsStore.getReportByExecutionId(executionId)
 
-      let statusResponse
-      if (timeoutRequest(reportData.timestamp.requested)) {
-        statusResponse = {
-          status: RequestStatus.FAILED,
-          errorMessage: 'Request taking too long. Request Halted',
-        }
-      } else {
-        statusResponse = await getStatus(
-          token,
-          reportId,
-          variantId,
-          executionId,
-          reportData.status,
-          dataSources,
-          asyncReportsStore,
-          reportData.dataProductDefinitionsPath,
-        )
+    let statusResponse
+    if (timeoutRequest(reportData.timestamp.requested)) {
+      statusResponse = {
+        status: RequestStatus.FAILED,
+        errorMessage: 'Request taking too long. Request Halted',
       }
-      const { status, errorMessage } = statusResponse
-      if (statusResponse.reportData) reportData = statusResponse.reportData
+    } else {
+      statusResponse = await getStatus(
+        token,
+        reportId,
+        variantId,
+        executionId,
+        reportData.status,
+        dataSources,
+        asyncReportsStore,
+        reportData.dataProductDefinitionsPath,
+      )
+    }
+    const { status, errorMessage } = statusResponse
+    if (statusResponse.reportData) reportData = statusResponse.reportData
 
-      return {
-        pollingRenderData: {
-          reportName: reportData.reportName,
-          variantName: reportData.name,
-          variantDescription: reportData.description,
-          executionId,
-          reportId,
-          variantId,
-          status,
-          tableId: reportData.tableId,
-          querySummary: reportData.query.summary,
-          ...(reportData.url.report?.fullUrl && { reportUrl: reportData.url.report.fullUrl }),
-          ...(reportData.url.request.fullUrl && { requestUrl: reportData.url.request.fullUrl }),
-          ...(errorMessage && { errorMessage }),
-        },
-      }
-    } catch (error) {
-      next(error)
-      return false
+    return {
+      pollingRenderData: {
+        reportName: reportData.reportName,
+        variantName: reportData.name,
+        variantDescription: reportData.description,
+        executionId,
+        reportId,
+        variantId,
+        status,
+        tableId: reportData.tableId,
+        querySummary: reportData.query.summary,
+        ...(reportData.url.report?.fullUrl && { reportUrl: reportData.url.report.fullUrl }),
+        ...(reportData.url.request.fullUrl && { requestUrl: reportData.url.request.fullUrl }),
+        ...(errorMessage && { errorMessage }),
+      },
     }
   },
 }

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

@@ -11,25 +11,19 @@ const utils_2 = __importDefault(require("../async-columns/utils"));
 const utils_3 = __importDefault(require("../pagination/utils"));
 const utils_4 = __importDefault(require("../icon-button-list/utils"));
 const initDataSources = ({ req, res, next, asyncReportsStore, dataSources }) => {
-    try {
-        const { token } = res.locals.user || 'token';
-        const { reportId, reportVariantId, tableId } = req.params;
-        const { selectedPage = 1, pageSize = 10 } = req.query;
-        const dataProductDefinitionsPath = req.query.dataProductDefinitionsPath;
-        const reportDefinitionPromise = dataSources.getDefinition(token, reportId, reportVariantId, dataProductDefinitionsPath);
-        const reportDataPromise = dataSources.getAsyncReport(token, reportId, reportVariantId, tableId, {
-            selectedPage: +selectedPage,
-            pageSize: +pageSize,
-            dataProductDefinitionsPath,
-        });
-        const reportDataCountPromise = dataSources.getAsyncCount(token, tableId);
-        const stateDataPromise = asyncReportsStore.getReportByTableId(tableId);
-        return [reportDefinitionPromise, reportDataPromise, reportDataCountPromise, stateDataPromise];
-    }
-    catch (error) {
-        next(error);
-        return false;
-    }
+    const { token } = res.locals.user || 'token';
+    const { reportId, reportVariantId, tableId } = req.params;
+    const { selectedPage = 1, pageSize = 10 } = req.query;
+    const dataProductDefinitionsPath = req.query.dataProductDefinitionsPath;
+    const reportDefinitionPromise = dataSources.getDefinition(token, reportId, reportVariantId, dataProductDefinitionsPath);
+    const reportDataPromise = dataSources.getAsyncReport(token, reportId, reportVariantId, tableId, {
+        selectedPage: +selectedPage,
+        pageSize: +pageSize,
+        dataProductDefinitionsPath,
+    });
+    const reportDataCountPromise = dataSources.getAsyncCount(token, tableId);
+    const stateDataPromise = asyncReportsStore.getReportByTableId(tableId);
+    return [reportDefinitionPromise, reportDataPromise, reportDataCountPromise, stateDataPromise];
 };
 exports.initDataSources = initDataSources;
 const renderReport = async ({ req, res, next, asyncReportsStore, recentlyViewedStoreService, dataSources, }) => {
@@ -38,8 +32,7 @@ const renderReport = async ({ req, res, next, asyncReportsStore, recentlyViewedS
     let renderData = {};
     let reportStateData;
     if (dataPromises) {
-        await Promise.all(dataPromises)
-            .then((resolvedData) => {
+        await Promise.all(dataPromises).then((resolvedData) => {
             const definition = resolvedData[0];
             const reportData = resolvedData[1];
             const count = resolvedData[2];
@@ -65,9 +58,6 @@ const renderReport = async ({ req, res, next, asyncReportsStore, recentlyViewedS
                 appliedFilters: query.summary,
                 classification,
             };
-        })
-            .catch((err) => {
-            next(err);
         });
     }
     if (Object.keys(renderData).length && Object.keys(reportStateData).length) {

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

@@ -11,30 +11,25 @@ import { AsyncReportUtilsParams } from '../../types/AsyncReportUtils'
 import { AsyncReportData } from '../../types/AsyncReport'
 
 export const initDataSources = ({ req, res, next, asyncReportsStore, dataSources }: AsyncReportUtilsParams) => {
-  try {
-    const { token } = res.locals.user || 'token'
-    const { reportId, reportVariantId, tableId } = req.params
-    const { selectedPage = 1, pageSize = 10 } = req.query
-    const dataProductDefinitionsPath = <string>req.query.dataProductDefinitionsPath
-    const reportDefinitionPromise = dataSources.getDefinition(
-      token,
-      reportId,
-      reportVariantId,
-      dataProductDefinitionsPath,
-    )
-    const reportDataPromise = dataSources.getAsyncReport(token, reportId, reportVariantId, tableId, {
-      selectedPage: +selectedPage,
-      pageSize: +pageSize,
-      dataProductDefinitionsPath,
-    })
-    const reportDataCountPromise = dataSources.getAsyncCount(token, tableId)
-    const stateDataPromise = asyncReportsStore.getReportByTableId(tableId)
+  const { token } = res.locals.user || 'token'
+  const { reportId, reportVariantId, tableId } = req.params
+  const { selectedPage = 1, pageSize = 10 } = req.query
+  const dataProductDefinitionsPath = <string>req.query.dataProductDefinitionsPath
+  const reportDefinitionPromise = dataSources.getDefinition(
+    token,
+    reportId,
+    reportVariantId,
+    dataProductDefinitionsPath,
+  )
+  const reportDataPromise = dataSources.getAsyncReport(token, reportId, reportVariantId, tableId, {
+    selectedPage: +selectedPage,
+    pageSize: +pageSize,
+    dataProductDefinitionsPath,
+  })
+  const reportDataCountPromise = dataSources.getAsyncCount(token, tableId)
+  const stateDataPromise = asyncReportsStore.getReportByTableId(tableId)
 
-    return [reportDefinitionPromise, reportDataPromise, reportDataCountPromise, stateDataPromise]
-  } catch (error) {
-    next(error)
-    return false
-  }
+  return [reportDefinitionPromise, reportDataPromise, reportDataCountPromise, stateDataPromise]
 }
 
 export const renderReport = async ({
@@ -52,40 +47,36 @@ export const renderReport = async ({
   let renderData = {}
   let reportStateData: AsyncReportData
   if (dataPromises) {
-    await Promise.all(dataPromises)
-      .then((resolvedData) => {
-        const definition = resolvedData[0] as unknown as components['schemas']['SingleVariantReportDefinition']
-        const reportData = <Array<Dict<string>>>resolvedData[1]
-        const count = <number>resolvedData[2]
-        reportStateData = <AsyncReportData>resolvedData[3]
+    await Promise.all(dataPromises).then((resolvedData) => {
+      const definition = resolvedData[0] as unknown as components['schemas']['SingleVariantReportDefinition']
+      const reportData = <Array<Dict<string>>>resolvedData[1]
+      const count = <number>resolvedData[2]
+      reportStateData = <AsyncReportData>resolvedData[3]
 
-        const fieldDefinition = definition.variant.specification.fields
-        const { classification } = definition.variant
+      const fieldDefinition = definition.variant.specification.fields
+      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)
-        const head = DataTableUtils.mapAsyncHeader(fieldDefinition, columns.value)
-        const { reportName, name: variantName, query, description } = reportStateData
+      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)
+      const head = DataTableUtils.mapAsyncHeader(fieldDefinition, columns.value)
+      const { reportName, name: variantName, query, description } = reportStateData
 
-        renderData = {
-          variantName,
-          reportName,
-          description,
-          rows,
-          head,
-          columns,
-          pagination,
-          actions,
-          appliedFilters: query.summary,
-          classification,
-        }
-      })
-      .catch((err) => {
-        next(err)
-      })
+      renderData = {
+        variantName,
+        reportName,
+        description,
+        rows,
+        head,
+        columns,
+        pagination,
+        actions,
+        appliedFilters: query.summary,
+        classification,
+      }
+    })
   }
 
   if (Object.keys(renderData).length && Object.keys(reportStateData).length) {

package/dpr/components/async-reports-list/utils/asyncReportsUtils.js

@@ -61,8 +61,7 @@ const setDataFromStatus = (status, requestedReportsData) => {
     let href;
     switch (status) {
         case AsyncReport_1.RequestStatus.FAILED: {
-            const retryParam = `&retryId=${requestedReportsData.executionId}`;
-            href = `${requestedReportsData.url.request.fullUrl}${retryParam}`;
+            href = `${requestedReportsData.url.polling.fullUrl}`;
             timestamp = `Failed at: ${new Date(requestedReportsData.timestamp.failed).toLocaleString()}`;
             break;
         }

package/dpr/components/async-reports-list/utils/asyncReportsUtils.ts

@@ -58,8 +58,7 @@ const setDataFromStatus = (status: RequestStatus, requestedReportsData: AsyncRep
   let href
   switch (status) {
     case RequestStatus.FAILED: {
-      const retryParam = `&retryId=${requestedReportsData.executionId}`
-      href = `${requestedReportsData.url.request.fullUrl}${retryParam}`
+      href = `${requestedReportsData.url.polling.fullUrl}`
       timestamp = `Failed at: ${new Date(requestedReportsData.timestamp.failed).toLocaleString()}`
       break
     }

package/dpr/routes/asyncReports.js

@@ -30,16 +30,29 @@ const utils_1 = __importDefault(require("../components/async-filters/utils"));
 const AsyncReportListUtils = __importStar(require("../components/async-report-list/utils"));
 const utils_2 = __importDefault(require("../components/async-polling/utils"));
 function routes({ router, asyncReportsStore, recentlyViewedStoreService, dataSources, layoutPath, templatePath = 'dpr/views/', }) {
-    // 1 - get filters for the report + make request
-    router.get('/async-reports/:reportId/:variantId/request', async (req, res, next) => {
-        res.render(`${templatePath}async-request`, {
-            title: 'Request Report',
+    const asyncErrorHandler = async (req, res) => {
+        res.render(`${templatePath}/async-error`, {
             layoutPath,
-            postEndpoint: '/requestReport/',
-            ...(await utils_1.default.renderFilters({ req, res, dataSources, next })),
+            ...req.body,
         });
-    });
-    // 2 - handle the post request to request the report data
+    };
+    const getReportFiltersHandler = async (req, res, next) => {
+        try {
+            const filtersRenderData = await utils_1.default.renderFilters({ req, res, dataSources, next });
+            res.render(`${templatePath}async-request`, {
+                title: 'Request Report',
+                layoutPath,
+                postEndpoint: '/requestReport/',
+                ...filtersRenderData,
+            });
+        }
+        catch (error) {
+            req.body.title = 'Report Failed';
+            req.body.description = 'Your report has failed to generate. The issue has been reported to admin staff';
+            req.body.error = error.data;
+            next();
+        }
+    };
     const asyncRequestHandler = async (req, res, next) => {
         try {
             const redirectToPollingPage = await utils_1.default.requestReport({
@@ -58,46 +71,59 @@ function routes({ router, asyncReportsStore, recentlyViewedStoreService, dataSou
             }
         }
         catch (error) {
-            req.body.error = JSON.parse(error.text);
+            req.body = {
+                ...req.body,
+                ...utils_1.default.handleError(error, req),
+            };
             next();
         }
     };
-    const asyncRequestErrorHandler = async (req, res, next) => {
-        const filters = Object.keys(req.body)
-            .filter((attr) => attr.includes('filters.'))
-            .filter((attr) => !!req.body[attr])
-            .map((attr) => {
-            return { name: attr, value: req.body[attr] };
-        });
-        res.render(`${templatePath}/async-error`, {
-            title: 'Request Failed',
-            layoutPath,
-            ...req.body,
-            filters,
-        });
+    const pollingHandler = async (req, res, next) => {
+        try {
+            const pollingRenderData = await utils_2.default.renderPolling({
+                req,
+                res,
+                dataSources,
+                asyncReportsStore,
+                next,
+            });
+            res.render(`${templatePath}/async-polling`, {
+                title: 'Report Request Status',
+                layoutPath,
+                ...pollingRenderData,
+            });
+        }
+        catch (error) {
+            req.body.title = 'Failed to retrieve Report status';
+            req.body.description = 'We were unable to retrieve the report status:';
+            req.body.error = error.data;
+            next();
+        }
     };
-    router.post('/requestReport/', asyncRequestHandler, asyncRequestErrorHandler);
-    // 3 - polling the status of the request
-    router.get('/async-reports/:reportId/:variantId/request/:executionId', async (req, res, next) => {
-        res.render(`${templatePath}/async-polling`, {
-            title: 'Report Requested',
-            layoutPath,
-            ...(await utils_2.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(`${templatePath}async-report`, {
-            layoutPath,
-            ...(await AsyncReportListUtils.renderReport({
+    const getReportListHandler = async (req, res, next) => {
+        try {
+            const reportRenderData = await AsyncReportListUtils.renderReport({
                 req,
                 res,
                 dataSources,
                 asyncReportsStore,
                 recentlyViewedStoreService,
                 next,
-            })),
-        });
-    });
+            });
+            res.render(`${templatePath}async-report`, {
+                layoutPath,
+                ...reportRenderData,
+            });
+        }
+        catch (error) {
+            req.body.title = 'Failed to retrieve Report';
+            req.body.description = 'We were unable to retrieve this report for the following reason:';
+            next();
+        }
+    };
+    router.get('/async-reports/:reportId/:variantId/request', getReportFiltersHandler, asyncErrorHandler);
+    router.post('/requestReport/', asyncRequestHandler, asyncErrorHandler);
+    router.get('/async-reports/:reportId/:variantId/request/:executionId', pollingHandler, asyncErrorHandler);
+    router.get('/async-reports/:reportId/:reportVariantId/request/:tableId/report', getReportListHandler, asyncErrorHandler);
 }
 exports.default = routes;

package/dpr/routes/asyncReports.ts

@@ -21,17 +21,30 @@ export default function routes({
   layoutPath: string
   templatePath?: string
 }) {
-  // 1 - get filters for the report + make request
-  router.get('/async-reports/:reportId/:variantId/request', async (req, res, next) => {
-    res.render(`${templatePath}async-request`, {
-      title: 'Request Report',
+  const asyncErrorHandler: RequestHandler = async (req, res) => {
+    res.render(`${templatePath}/async-error`, {
       layoutPath,
-      postEndpoint: '/requestReport/',
-      ...(await AsyncFiltersUtils.renderFilters({ req, res, dataSources, next })),
+      ...req.body,
     })
-  })
+  }
+
+  const getReportFiltersHandler: RequestHandler = async (req, res, next) => {
+    try {
+      const filtersRenderData = await AsyncFiltersUtils.renderFilters({ req, res, dataSources, next })
+      res.render(`${templatePath}async-request`, {
+        title: 'Request Report',
+        layoutPath,
+        postEndpoint: '/requestReport/',
+        ...filtersRenderData,
+      })
+    } catch (error) {
+      req.body.title = 'Report Failed'
+      req.body.description = 'Your report has failed to generate. The issue has been reported to admin staff'
+      req.body.error = error.data
+      next()
+    }
+  }
 
-  // 2 - handle the post request to request the report data
   const asyncRequestHandler: RequestHandler = async (req, res, next) => {
     try {
       const redirectToPollingPage = await AsyncFiltersUtils.requestReport({
@@ -48,49 +61,63 @@ export default function routes({
         res.end()
       }
     } catch (error) {
-      req.body.error = JSON.parse(error.text)
+      req.body = {
+        ...req.body,
+        ...AsyncFiltersUtils.handleError(error, req),
+      }
       next()
     }
   }
 
-  const asyncRequestErrorHandler: RequestHandler = async (req, res, next) => {
-    const filters = Object.keys(req.body)
-      .filter((attr) => attr.includes('filters.'))
-      .filter((attr) => !!req.body[attr])
-      .map((attr) => {
-        return { name: attr, value: req.body[attr] }
+  const pollingHandler: RequestHandler = async (req, res, next) => {
+    try {
+      const pollingRenderData = await AsyncPollingUtils.renderPolling({
+        req,
+        res,
+        dataSources,
+        asyncReportsStore,
+        next,
       })
-    res.render(`${templatePath}/async-error`, {
-      title: 'Request Failed',
-      layoutPath,
-      ...req.body,
-      filters,
-    })
+      res.render(`${templatePath}/async-polling`, {
+        title: 'Report Request Status',
+        layoutPath,
+        ...pollingRenderData,
+      })
+    } catch (error) {
+      req.body.title = 'Failed to retrieve Report status'
+      req.body.description = 'We were unable to retrieve the report status:'
+      req.body.error = error.data
+      next()
+    }
   }
 
-  router.post('/requestReport/', asyncRequestHandler, asyncRequestErrorHandler)
-
-  // 3 - polling the status of the request
-  router.get('/async-reports/:reportId/:variantId/request/:executionId', async (req, res, next) => {
-    res.render(`${templatePath}/async-polling`, {
-      title: 'Report Requested',
-      layoutPath,
-      ...(await AsyncPollingUtils.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(`${templatePath}async-report`, {
-      layoutPath,
-      ...(await AsyncReportListUtils.renderReport({
+  const getReportListHandler: RequestHandler = async (req, res, next) => {
+    try {
+      const reportRenderData = await AsyncReportListUtils.renderReport({
         req,
         res,
         dataSources,
         asyncReportsStore,
         recentlyViewedStoreService,
         next,
-      })),
-    })
-  })
+      })
+      res.render(`${templatePath}async-report`, {
+        layoutPath,
+        ...reportRenderData,
+      })
+    } catch (error) {
+      req.body.title = 'Failed to retrieve Report'
+      req.body.description = 'We were unable to retrieve this report for the following reason:'
+      next()
+    }
+  }
+
+  router.get('/async-reports/:reportId/:variantId/request', getReportFiltersHandler, asyncErrorHandler)
+  router.post('/requestReport/', asyncRequestHandler, asyncErrorHandler)
+  router.get('/async-reports/:reportId/:variantId/request/:executionId', pollingHandler, asyncErrorHandler)
+  router.get(
+    '/async-reports/:reportId/:reportVariantId/request/:tableId/report',
+    getReportListHandler,
+    asyncErrorHandler,
+  )
 }

package/dpr/views/async-error.njk

@@ -12,7 +12,7 @@
   <p>Status: {{ dprRequestStatusTag(error.status) }}</p>
 
   {{ govukErrorSummary({
-    titleText: "Your report has failed to generate. The issue has been reported to admin staff",
+    titleText: description,
     classes: "govuk-!-margin-top-6",
     errorList: [
       {
@@ -31,12 +31,16 @@
   {% endif %}
   {% endset %}
 
-  {{ dprAsyncRequestDetails( reportName, variantName, description, filtersHtml )}}
+  {% if reportName %}
+    {{ dprAsyncRequestDetails( reportName, variantName, description, filtersHtml )}}
+  {% endif %}
 
-  {{ govukButton({
+  {% if retry %}
+    {{ govukButton({
     id: "retry-async-request",
     text: "Retry",  
     classes: "govuk-button govuk-!-margin-top-5",
     href: href
   }) }}
+  {% endif %}
 {% endblock %}

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.10.2",
+  "version": "3.10.3",
   "main": "dpr/assets/js/all.mjs",
   "sass": "dpr/all.scss",
   "engines": {