@ministryofjustice/hmpps-digital-prison-reporting-frontend 4.2.2 → 4.2.4

package/dpr/all.mjs

@@ -276,7 +276,7 @@ class BookmarkToggle extends DprClientClass {
   }
 
   async toggleBookmark(type, id, reportId, reportType, csrfToken) {
-    const endpoint = type === 'add' ? '/addBookmark/' : '/removeBookmark/';
+    const endpoint = type === 'add' ? '/dpr/addBookmark/' : '/dpr/removeBookmark/';
     await fetch(endpoint, {
       method: 'post',
       headers: {
@@ -1065,7 +1065,7 @@ class DprPollingStatusClass extends DprClientClass {
   }
 
   async getRequestStatus(metaData, csrfToken) {
-    return this.getStatus('/getStatus/', metaData, csrfToken)
+    return this.getStatus('/dpr/getStatus/', metaData, csrfToken)
   }
 
   async getExpiredStatus(endpoint, metaData, csrfToken) {
@@ -1161,7 +1161,7 @@ class DprAsyncPolling extends DprPollingStatusClass {
       const csrfToken = this.cancelRequestButton.getAttribute('data-csrf-token');
 
       this.cancelRequestButton.addEventListener('click', async () => {
-        await fetch('/cancelRequest/', {
+        await fetch('/dpr/cancelRequest/', {
           method: 'post',
           headers: {
             Accept: 'application/json',
@@ -1851,7 +1851,7 @@ class DprAsyncRequestList extends DprPollingStatusClass {
     await Promise.all(
       JSON.parse(this.requestData).map(async (metaData) => {
         if (!this.EXPIRED_END_STATUSES.includes(metaData.status)) {
-          const response = await this.getExpiredStatus('/getRequestedExpiredStatus/', metaData, this.csrfToken);
+          const response = await this.getExpiredStatus('/dpr/getRequestedExpiredStatus/', metaData, this.csrfToken);
 
           if (response && response.isExpired) {
             clearInterval(this.expiredInterval);
@@ -1891,7 +1891,7 @@ class DprAsyncRequestList extends DprPollingStatusClass {
 
   async removeItemFromList(executionId) {
     let response;
-    await fetch('/removeRequestedItem/', {
+    await fetch('/dpr/removeRequestedItem/', {
       method: 'post',
       headers: {
         Accept: 'application/json',
@@ -1945,7 +1945,7 @@ class DprRecentlyViewedList extends DprPollingStatusClass {
     await Promise.all(
       JSON.parse(this.viewedReportData).map(async (metaData) => {
         if (metaData.status !== 'EXPIRED') {
-          const response = await this.getExpiredStatus('/getExpiredStatus/', metaData, this.csrfToken);
+          const response = await this.getExpiredStatus('/dpr/getExpiredStatus/', metaData, this.csrfToken);
           if (response && response.isExpired) {
             window.location.reload();
             clearInterval(this.expiredViewedInterval);
@@ -1967,7 +1967,7 @@ class DprRecentlyViewedList extends DprPollingStatusClass {
 
   async removeItemFromList(executionId) {
     let response;
-    await fetch('/removeViewedItem/', {
+    await fetch('/dpr/removeViewedItem/', {
       method: 'post',
       headers: {
         Accept: 'application/json',

package/dpr/assets/js/all.mjs

@@ -249,7 +249,7 @@ class BookmarkToggle extends DprClientClass {
   }
 
   async toggleBookmark(type, id, reportId, reportType, csrfToken) {
-    const endpoint = type === 'add' ? '/addBookmark/' : '/removeBookmark/';
+    const endpoint = type === 'add' ? '/dpr/addBookmark/' : '/dpr/removeBookmark/';
     await fetch(endpoint, {
       method: 'post',
       headers: {
@@ -1038,7 +1038,7 @@ class DprPollingStatusClass extends DprClientClass {
   }
 
   async getRequestStatus(metaData, csrfToken) {
-    return this.getStatus('/getStatus/', metaData, csrfToken)
+    return this.getStatus('/dpr/getStatus/', metaData, csrfToken)
   }
 
   async getExpiredStatus(endpoint, metaData, csrfToken) {
@@ -1134,7 +1134,7 @@ class DprAsyncPolling extends DprPollingStatusClass {
       const csrfToken = this.cancelRequestButton.getAttribute('data-csrf-token');
 
       this.cancelRequestButton.addEventListener('click', async () => {
-        await fetch('/cancelRequest/', {
+        await fetch('/dpr/cancelRequest/', {
           method: 'post',
           headers: {
             Accept: 'application/json',
@@ -1824,7 +1824,7 @@ class DprAsyncRequestList extends DprPollingStatusClass {
     await Promise.all(
       JSON.parse(this.requestData).map(async (metaData) => {
         if (!this.EXPIRED_END_STATUSES.includes(metaData.status)) {
-          const response = await this.getExpiredStatus('/getRequestedExpiredStatus/', metaData, this.csrfToken);
+          const response = await this.getExpiredStatus('/dpr/getRequestedExpiredStatus/', metaData, this.csrfToken);
 
           if (response && response.isExpired) {
             clearInterval(this.expiredInterval);
@@ -1864,7 +1864,7 @@ class DprAsyncRequestList extends DprPollingStatusClass {
 
   async removeItemFromList(executionId) {
     let response;
-    await fetch('/removeRequestedItem/', {
+    await fetch('/dpr/removeRequestedItem/', {
       method: 'post',
       headers: {
         Accept: 'application/json',
@@ -1918,7 +1918,7 @@ class DprRecentlyViewedList extends DprPollingStatusClass {
     await Promise.all(
       JSON.parse(this.viewedReportData).map(async (metaData) => {
         if (metaData.status !== 'EXPIRED') {
-          const response = await this.getExpiredStatus('/getExpiredStatus/', metaData, this.csrfToken);
+          const response = await this.getExpiredStatus('/dpr/getExpiredStatus/', metaData, this.csrfToken);
           if (response && response.isExpired) {
             window.location.reload();
             clearInterval(this.expiredViewedInterval);
@@ -1940,7 +1940,7 @@ class DprRecentlyViewedList extends DprPollingStatusClass {
 
   async removeItemFromList(executionId) {
     let response;
-    await fetch('/removeViewedItem/', {
+    await fetch('/dpr/removeViewedItem/', {
       method: 'post',
       headers: {
         Accept: 'application/json',

package/dpr/components/_reports/report-actions/view.njk

@@ -20,7 +20,7 @@
       } %}
 
     {% if not button.disabled %}
-      <form id="download-report-form" action="/downloadReport/" method="post">
+      <form id="download-report-form" action="/dpr/downloadReport/" method="post">
         <input type="hidden" name="dataProductDefinitionsPath" value="{{ button.attributes.definitionPath }}">
         <input type="hidden" name="_csrf" value="{{ button.attributes.csrfToken }}">
         <input type="hidden" name="reportId" value="{{ button.attributes.reportId }}">

package/dpr/components/download-feeback-form/view.njk

@@ -23,7 +23,7 @@
 
   <div class="dpr-download-feedback-form-wrapper" data-dpr-module="download-feedback-form">
 
-    <form action="/submitFeedback/" method="post" id="download-feedback-form" class="download-feedback-form--hidden">
+    <form action="/dpr/submitFeedback/" method="post" id="download-feedback-form" class="download-feedback-form--hidden">
 
       <p>To enable downloads for this report (<strong>{{ reportName}} - {{ variantName }}</strong>), take a few moments to fill out this request form.</p><p>Once you have submitted the form you the download button will be enabled immediately.</p>
 

package/dpr/middleware/setUpDprResources.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateRequestedReports = exports.populateDefinitions = exports.setRoutePrefix = void 0;
+const definitionUtils_1 = __importDefault(require("../utils/definitionUtils"));
+const urlHelper_1 = require("../utils/urlHelper");
+const getQueryParamAsString = (query, name) => (query[name] ? query[name].toString() : null);
+const getDefinitionsPath = (query) => getQueryParamAsString(query, 'dataProductDefinitionsPath');
+const deriveDefinitionsPath = (query) => {
+    const definitionsPath = getDefinitionsPath(query);
+    if (definitionsPath) {
+        return definitionsPath;
+    }
+    return null;
+};
+exports.default = (services, config) => {
+    return async (req, res, next) => {
+        try {
+            await (0, exports.populateDefinitions)(services, req, res, config);
+            await (0, exports.populateRequestedReports)(services, res);
+            (0, exports.setRoutePrefix)(res, config);
+            return next();
+        }
+        catch (error) {
+            return next(error);
+        }
+    };
+};
+const setRoutePrefix = async (res, config) => {
+    res.locals.routePrefix = (0, urlHelper_1.getRoutePrefix)(config);
+};
+exports.setRoutePrefix = setRoutePrefix;
+const populateDefinitions = async (services, req, res, config) => {
+    // Get the DPD path from the query
+    const dpdPathFromQuery = deriveDefinitionsPath(req.query);
+    const dpdPathFromBody = req.body.dataProductDefinitionsPath;
+    const definitionsPathFromQuery = dpdPathFromQuery || dpdPathFromBody;
+    if (definitionsPathFromQuery) {
+        res.locals.dpdPathFromQuery = true;
+    }
+    // Get the DPD path from the config
+    const dpdPathFromConfig = config === null || config === void 0 ? void 0 : config.dataProductDefinitionsPath;
+    if (dpdPathFromConfig) {
+        res.locals.dpdPathFromConfig = true;
+    }
+    // query takes presedence over config
+    res.locals.definitionsPath = definitionsPathFromQuery || dpdPathFromConfig;
+    res.locals.pathSuffix = `?dataProductDefinitionsPath=${res.locals.definitionsPath}`;
+    if (res.locals.user.token && services.reportingService) {
+        res.locals.definitions = await services.reportingService.getDefinitions(res.locals.user.token, res.locals.definitionsPath);
+    }
+};
+exports.populateDefinitions = populateDefinitions;
+const populateRequestedReports = async (services, res) => {
+    if (res.locals.user) {
+        const { uuid: userId } = res.locals.user;
+        const { definitions, definitionsPath } = res.locals;
+        const requested = await services.requestedReportService.getAllReports(userId);
+        res.locals.requestedReports = !definitionsPath
+            ? requested
+            : requested.filter((report) => {
+                return definitionUtils_1.default.getCurrentVariantDefinition(definitions, report.reportId, report.id);
+            });
+        const recent = await services.recentlyViewedService.getAllReports(userId);
+        res.locals.recentlyViewedReports = !definitionsPath
+            ? recent
+            : recent.filter((report) => {
+                return definitionUtils_1.default.getCurrentVariantDefinition(definitions, report.reportId, report.id);
+            });
+        if (services.bookmarkService) {
+            res.locals.bookmarkingEnabled = true;
+            const bookmarks = await services.bookmarkService.getAllBookmarks(userId);
+            res.locals.bookmarks = !definitionsPath
+                ? bookmarks
+                : bookmarks.filter((bookmark) => {
+                    return definitionUtils_1.default.getCurrentVariantDefinition(definitions, bookmark.reportId, bookmark.id);
+                });
+        }
+        if (services.downloadPermissionService) {
+            res.locals.downloadingEnabled = true;
+        }
+    }
+};
+exports.populateRequestedReports = populateRequestedReports;

package/dpr/middleware/setUpDprResources.ts

@@ -0,0 +1,102 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { RequestHandler, Response, Request } from 'express'
+import type { ParsedQs } from 'qs'
+import { Services } from '../types/Services'
+import { RequestedReport, StoredReportData } from '../types/UserReports'
+import DefinitionUtils from '../utils/definitionUtils'
+import { BookmarkStoreData } from '../types/Bookmark'
+import { getRoutePrefix } from '../utils/urlHelper'
+import { DprConfig } from '../types/DprConfig'
+
+const getQueryParamAsString = (query: ParsedQs, name: string) => (query[name] ? query[name].toString() : null)
+const getDefinitionsPath = (query: ParsedQs) => getQueryParamAsString(query, 'dataProductDefinitionsPath')
+
+const deriveDefinitionsPath = (query: ParsedQs): string | null => {
+  const definitionsPath = getDefinitionsPath(query)
+  if (definitionsPath) {
+    return definitionsPath
+  }
+
+  return null
+}
+
+export default (services: Services, config?: DprConfig): RequestHandler => {
+  return async (req, res, next) => {
+    try {
+      await populateDefinitions(services, req, res, config)
+      await populateRequestedReports(services, res)
+      setRoutePrefix(res, config)
+      return next()
+    } catch (error) {
+      return next(error)
+    }
+  }
+}
+
+export const setRoutePrefix = async (res: Response, config?: DprConfig) => {
+  res.locals.routePrefix = getRoutePrefix(config)
+}
+
+export const populateDefinitions = async (services: Services, req: Request, res: Response, config?: DprConfig) => {
+  // Get the DPD path from the query
+  const dpdPathFromQuery = deriveDefinitionsPath(req.query)
+  const dpdPathFromBody = req.body.dataProductDefinitionsPath
+  const definitionsPathFromQuery = dpdPathFromQuery || dpdPathFromBody
+
+  if (definitionsPathFromQuery) {
+    res.locals.dpdPathFromQuery = true
+  }
+
+  // Get the DPD path from the config
+  const dpdPathFromConfig = config?.dataProductDefinitionsPath
+  if (dpdPathFromConfig) {
+    res.locals.dpdPathFromConfig = true
+  }
+
+  // query takes presedence over config
+  res.locals.definitionsPath = definitionsPathFromQuery || dpdPathFromConfig
+  res.locals.pathSuffix = `?dataProductDefinitionsPath=${res.locals.definitionsPath}`
+
+  if (res.locals.user.token && services.reportingService) {
+    res.locals.definitions = await services.reportingService.getDefinitions(
+      res.locals.user.token,
+      res.locals.definitionsPath,
+    )
+  }
+}
+
+export const populateRequestedReports = async (services: Services, res: Response) => {
+  if (res.locals.user) {
+    const { uuid: userId } = res.locals.user
+    const { definitions, definitionsPath } = res.locals
+
+    const requested = await services.requestedReportService.getAllReports(userId)
+    res.locals.requestedReports = !definitionsPath
+      ? requested
+      : requested.filter((report: RequestedReport) => {
+          return DefinitionUtils.getCurrentVariantDefinition(definitions, report.reportId, report.id)
+        })
+
+    const recent = await services.recentlyViewedService.getAllReports(userId)
+    res.locals.recentlyViewedReports = !definitionsPath
+      ? recent
+      : recent.filter((report: StoredReportData) => {
+          return DefinitionUtils.getCurrentVariantDefinition(definitions, report.reportId, report.id)
+        })
+
+    if (services.bookmarkService) {
+      res.locals.bookmarkingEnabled = true
+
+      const bookmarks = await services.bookmarkService.getAllBookmarks(userId)
+      res.locals.bookmarks = !definitionsPath
+        ? bookmarks
+        : bookmarks.filter((bookmark: BookmarkStoreData) => {
+            return DefinitionUtils.getCurrentVariantDefinition(definitions, bookmark.reportId, bookmark.id)
+          })
+    }
+
+    if (services.downloadPermissionService) {
+      res.locals.downloadingEnabled = true
+    }
+  }
+}

package/dpr/routes/DprEmbeddedReports.js

@@ -10,16 +10,21 @@ const download_1 = __importDefault(require("./download"));
 const recentlyViewed_1 = __importDefault(require("./recentlyViewed"));
 const syncReports_1 = __importDefault(require("./syncReports"));
 const logger_1 = __importDefault(require("../utils/logger"));
+const urlHelper_1 = require("../utils/urlHelper");
 function routes(routeImportParams) {
     logger_1.default.info('Initialiasing DPR Embedded reports routes...');
-    (0, asyncReports_1.default)(routeImportParams);
-    (0, recentlyViewed_1.default)(routeImportParams);
-    (0, syncReports_1.default)(routeImportParams);
+    const params = {
+        ...routeImportParams,
+        prefix: (0, urlHelper_1.getRoutePrefix)(routeImportParams === null || routeImportParams === void 0 ? void 0 : routeImportParams.config),
+    };
+    (0, asyncReports_1.default)(params);
+    (0, recentlyViewed_1.default)(params);
+    (0, syncReports_1.default)(params);
     const { bookmarkService, downloadPermissionService } = routeImportParams.services;
     if (bookmarkService) {
-        (0, bookmarks_1.default)(routeImportParams);
+        (0, bookmarks_1.default)(params);
     }
     if (downloadPermissionService) {
-        (0, download_1.default)(routeImportParams);
+        (0, download_1.default)(params);
     }
 }

package/dpr/routes/DprEmbeddedReports.ts

@@ -7,21 +7,33 @@ import addSyncRoutes from './syncReports'
 
 import type { Services } from '../types/Services'
 import logger from '../utils/logger'
+import { getRoutePrefix } from '../utils/urlHelper'
+import { DprConfig } from '../types/DprConfig'
 
-export default function routes(routeImportParams: { router: Router; services: Services; layoutPath: string }) {
+export default function routes(routeImportParams: {
+  router: Router
+  services: Services
+  layoutPath: string
+  config?: DprConfig
+}) {
   logger.info('Initialiasing DPR Embedded reports routes...')
 
-  addAsyncReportingRoutes(routeImportParams)
-  addRecentlyViewedRoutes(routeImportParams)
-  addSyncRoutes(routeImportParams)
+  const params = {
+    ...routeImportParams,
+    prefix: getRoutePrefix(routeImportParams?.config),
+  }
+
+  addAsyncReportingRoutes(params)
+  addRecentlyViewedRoutes(params)
+  addSyncRoutes(params)
 
   const { bookmarkService, downloadPermissionService } = routeImportParams.services
 
   if (bookmarkService) {
-    addBookmarkingRoutes(routeImportParams)
+    addBookmarkingRoutes(params)
   }
 
   if (downloadPermissionService) {
-    addDownloadRoutes(routeImportParams)
+    addDownloadRoutes(params)
   }
 }

package/dpr/routes/asyncReports.js

@@ -14,7 +14,7 @@ const localsHelper_1 = __importDefault(require("../utils/localsHelper"));
 const utils_7 = __importDefault(require("../components/_async/async-report/utils"));
 const logger_1 = __importDefault(require("../utils/logger"));
 const UserReports_1 = require("../types/UserReports");
-function routes({ router, services, layoutPath, }) {
+function routes({ router, services, layoutPath, prefix, }) {
     logger_1.default.info('Initialiasing routes: Async reports');
     /**   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *
      *                                                            *
@@ -90,7 +90,7 @@ function routes({ router, services, layoutPath, }) {
             });
             res.render(`dpr/views/async-request`, {
                 layoutPath,
-                postEndpoint: '/requestReport/',
+                postEndpoint: '/dpr/requestReport/',
                 ...requestRenderData,
             });
         }
@@ -306,59 +306,21 @@ function routes({ router, services, layoutPath, }) {
             })),
         });
     };
-    /**
-     * NOTE:
-     * - The async route paths have been made more generic with the introduction of `type`, to allow other report types (e.g dashboard) to follow the async path
-     * - All requests will be made to the this new route.
-     *
-     * - Previously stored requested and viewed reports in Redis will have the old route path. Which is redirected to the new path.
-     * - As requests expire after 24hrs, eventually the old route will dissapear from the requested and viewed store and only include the new route.
-     * - At this point we can consider removing this route all together
-     */
     // 1 - REQUEST
-    router.get('/async/:type/:reportId/:id/request', isAuthorisedToViewReport, renderRequestHandler, asyncErrorHandler);
-    router.post('/requestReport/', asyncRequestHandler, asyncErrorHandler);
+    router.get(`${prefix}/async/:type/:reportId/:id/request`, isAuthorisedToViewReport, renderRequestHandler, asyncErrorHandler);
+    router.post('/dpr/requestReport/', asyncRequestHandler, asyncErrorHandler);
     // 2 - POLLING
-    router.get('/async/:type/:reportId/:id/request/:executionId', pollingHandler, asyncErrorHandler);
-    router.post('/getStatus/', getStatusHandler);
-    router.post('/cancelRequest/', cancelRequestHandler, asyncErrorHandler);
+    router.get(`${prefix}/async/:type/:reportId/:id/request/:executionId`, pollingHandler, asyncErrorHandler);
+    router.post('/dpr/getStatus/', getStatusHandler);
+    router.post('/dpr/cancelRequest/', cancelRequestHandler, asyncErrorHandler);
     // 3 - VIEw REPORT
     const viewReportPaths = [
-        '/async/:type/:reportId/:id/request/:tableId/report',
-        '/async/:type/:reportId/:id/request/:tableId/report/:download',
+        `${prefix}/async/:type/:reportId/:id/request/:tableId/report`,
+        `${prefix}/async/:type/:reportId/:id/request/:tableId/report/:download`,
     ];
     router.get(viewReportPaths, isAuthorisedToViewReport, viewReportHandler, asyncErrorHandler);
     // Homepage widget routes
-    router.post('/removeRequestedItem/', removeRequestedItemHandler, asyncErrorHandler);
-    router.post('/getRequestedExpiredStatus/', getExpiredStatus);
-    router.get('/async-reports/requested', listingHandler);
-    // REDIRECTS
-    const setQueryParams = (req, url) => {
-        const queryString = new URLSearchParams(req.query).toString();
-        if (queryString.length) {
-            return `${url}?${queryString}`;
-        }
-        return url;
-    };
-    // Request
-    router.get('/async-reports/:reportId/:variantId/request', async (req, res, next) => {
-        const { reportId, variantId: id } = req.params;
-        let url = `/async/report/${reportId}/${id}/request`;
-        url = setQueryParams(req, url);
-        res.redirect(url);
-    });
-    // POLLING
-    router.get('/async-reports/:reportId/:variantId/request/:executionId', async (req, res, next) => {
-        const { reportId, variantId: id, executionId } = req.params;
-        let url = `/async/report/${reportId}/${id}/request/${executionId}`;
-        url = setQueryParams(req, url);
-        res.redirect(url);
-    });
-    // REPORT
-    router.get('/async-reports/:reportId/:variantId/request/:tableId/report', async (req, res, next) => {
-        const { reportId, variantId: id, tableId } = req.params;
-        let url = `/async/report/${reportId}/${id}/request/${tableId}/report`;
-        url = setQueryParams(req, url);
-        res.redirect(url);
-    });
+    router.post('/dpr/removeRequestedItem/', removeRequestedItemHandler, asyncErrorHandler);
+    router.post('/dpr/getRequestedExpiredStatus/', getExpiredStatus);
+    router.get(`${prefix}/async-reports/requested`, listingHandler);
 }

package/dpr/routes/asyncReports.ts

@@ -1,4 +1,5 @@
-import type { RequestHandler, Router, Request } from 'express'
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { RequestHandler, Router } from 'express'
 import AsyncPollingUtils from '../components/_async/async-polling/utils'
 import AsyncRequestListUtils from '../components/user-reports/requested/utils'
 import UserReportsListUtils from '../components/user-reports/utils'
@@ -18,10 +19,12 @@ export default function routes({
   router,
   services,
   layoutPath,
+  prefix,
 }: {
   router: Router
   services: Services
   layoutPath: string
+  prefix: string
 }) {
   logger.info('Initialiasing routes: Async reports')
 
@@ -104,7 +107,7 @@ export default function routes({
 
       res.render(`dpr/views/async-request`, {
         layoutPath,
-        postEndpoint: '/requestReport/',
+        postEndpoint: '/dpr/requestReport/',
         ...requestRenderData,
       })
     } catch (error) {
@@ -327,68 +330,29 @@ export default function routes({
     })
   }
 
-  /**
-   * NOTE:
-   * - The async route paths have been made more generic with the introduction of `type`, to allow other report types (e.g dashboard) to follow the async path
-   * - All requests will be made to the this new route.
-   *
-   * - Previously stored requested and viewed reports in Redis will have the old route path. Which is redirected to the new path.
-   * - As requests expire after 24hrs, eventually the old route will dissapear from the requested and viewed store and only include the new route.
-   * - At this point we can consider removing this route all together
-   */
-
   // 1 - REQUEST
-  router.get('/async/:type/:reportId/:id/request', isAuthorisedToViewReport, renderRequestHandler, asyncErrorHandler)
-  router.post('/requestReport/', asyncRequestHandler, asyncErrorHandler)
+  router.get(
+    `${prefix}/async/:type/:reportId/:id/request`,
+    isAuthorisedToViewReport,
+    renderRequestHandler,
+    asyncErrorHandler,
+  )
+  router.post('/dpr/requestReport/', asyncRequestHandler, asyncErrorHandler)
 
   // 2 - POLLING
-  router.get('/async/:type/:reportId/:id/request/:executionId', pollingHandler, asyncErrorHandler)
-  router.post('/getStatus/', getStatusHandler)
-  router.post('/cancelRequest/', cancelRequestHandler, asyncErrorHandler)
+  router.get(`${prefix}/async/:type/:reportId/:id/request/:executionId`, pollingHandler, asyncErrorHandler)
+  router.post('/dpr/getStatus/', getStatusHandler)
+  router.post('/dpr/cancelRequest/', cancelRequestHandler, asyncErrorHandler)
 
   // 3 - VIEw REPORT
   const viewReportPaths = [
-    '/async/:type/:reportId/:id/request/:tableId/report',
-    '/async/:type/:reportId/:id/request/:tableId/report/:download',
+    `${prefix}/async/:type/:reportId/:id/request/:tableId/report`,
+    `${prefix}/async/:type/:reportId/:id/request/:tableId/report/:download`,
   ]
   router.get(viewReportPaths, isAuthorisedToViewReport, viewReportHandler, asyncErrorHandler)
 
   // Homepage widget routes
-  router.post('/removeRequestedItem/', removeRequestedItemHandler, asyncErrorHandler)
-  router.post('/getRequestedExpiredStatus/', getExpiredStatus)
-  router.get('/async-reports/requested', listingHandler)
-
-  // REDIRECTS
-
-  const setQueryParams = (req: Request, url: string) => {
-    const queryString = new URLSearchParams(req.query as unknown as URLSearchParams).toString()
-    if (queryString.length) {
-      return `${url}?${queryString}`
-    }
-    return url
-  }
-
-  // Request
-  router.get('/async-reports/:reportId/:variantId/request', async (req, res, next) => {
-    const { reportId, variantId: id } = req.params
-    let url = `/async/report/${reportId}/${id}/request`
-    url = setQueryParams(req, url)
-    res.redirect(url)
-  })
-
-  // POLLING
-  router.get('/async-reports/:reportId/:variantId/request/:executionId', async (req, res, next) => {
-    const { reportId, variantId: id, executionId } = req.params
-    let url = `/async/report/${reportId}/${id}/request/${executionId}`
-    url = setQueryParams(req, url)
-    res.redirect(url)
-  })
-
-  // REPORT
-  router.get('/async-reports/:reportId/:variantId/request/:tableId/report', async (req, res, next) => {
-    const { reportId, variantId: id, tableId } = req.params
-    let url = `/async/report/${reportId}/${id}/request/${tableId}/report`
-    url = setQueryParams(req, url)
-    res.redirect(url)
-  })
+  router.post('/dpr/removeRequestedItem/', removeRequestedItemHandler, asyncErrorHandler)
+  router.post('/dpr/getRequestedExpiredStatus/', getExpiredStatus)
+  router.get(`${prefix}/async-reports/requested`, listingHandler)
 }

package/dpr/routes/bookmarks.js

@@ -6,23 +6,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = routes;
 const utils_1 = __importDefault(require("../components/user-reports/bookmarks/utils"));
 const logger_1 = __importDefault(require("../utils/logger"));
-function routes({ router, services, layoutPath, templatePath = 'dpr/views/', }) {
+function routes({ router, services, layoutPath, prefix, }) {
     logger_1.default.info('Initialiasing routes: Bookmarks');
-    router.post('/addBookmark/', async (req, res) => {
+    router.post('/dpr/addBookmark/', async (req, res) => {
         var _a;
         const userId = ((_a = res.locals.user) === null || _a === void 0 ? void 0 : _a.uuid) ? res.locals.user.uuid : 'userId';
         const { reportId, id, reportType } = req.body;
         await services.bookmarkService.addBookmark(userId, reportId, id, reportType);
         res.end();
     });
-    router.post('/removeBookmark/', async (req, res) => {
+    router.post('/dpr/removeBookmark/', async (req, res) => {
         var _a;
         const userId = ((_a = res.locals.user) === null || _a === void 0 ? void 0 : _a.uuid) ? res.locals.user.uuid : 'userId';
         await services.bookmarkService.removeBookmark(userId, req.body.id);
         res.end();
     });
-    router.get('/async-reports/bookmarks', async (req, res) => {
-        res.render(`${templatePath}/async-reports`, {
+    router.get(`${prefix}/async-reports/bookmarks`, async (req, res) => {
+        res.render(`dpr/views/async-reports`, {
             title: 'Requested Reports',
             layoutPath,
             ...(await utils_1.default.renderBookmarkList({ services, res, req })),