@ministryofjustice/hmpps-digital-prison-reporting-frontend/dpr/utils/report/syncReportUtils.js

The Digital Prison Reporting Frontend contains templates and code to help display data effectively in UI applications.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const parseurl_1 = __importDefault(require("parseurl"));
const UserReports_1 = require("../../types/UserReports");
const ReportQuery_1 = __importDefault(require("../../types/ReportQuery"));
const utils_1 = __importDefault(require("../../components/_reports/report-pagination/utils"));
const utils_2 = __importDefault(require("../../components/_reports/report-totals/utils"));
const utils_3 = __importDefault(require("../../components/_reports/report-columns-form/utils"));
const utils_4 = __importDefault(require("../../components/_reports/report-actions/utils"));
const utils_5 = __importDefault(require("../../components/_filters/utils"));
const localsHelper_1 = __importDefault(require("../localsHelper"));
const UserStoreItemBuilder_1 = __importDefault(require("../UserStoreItemBuilder"));
const DataTableBuilder_1 = __importDefault(require("../DataTableBuilder/DataTableBuilder"));
const setActions = (csrfToken, reportDefinition, columns, url, canDownload, count, dataProductDefinitionsPath, currentUrl, currentQueryParams) => {
    const { name: reportName, variant, id: reportId } = reportDefinition;
    const { name, id, printable } = variant;
    const downloadConfig = {
        enabled: count > 0,
        name,
        reportName,
        csrfToken,
        reportId,
        id,
        columns: columns.value,
        loadType: UserReports_1.LoadType.SYNC,
        definitionPath: dataProductDefinitionsPath,
        canDownload,
        currentUrl,
        currentQueryParams,
    };
    return utils_4.default.getActions({
        download: downloadConfig,
        print: {
            enabled: printable,
        },
        share: {
            reportName,
            name,
            url,
        },
        copy: {
            url,
        },
    });
};
const setAsRecentlyViewed = async (req, services, reportName, name, description, reportId, id, userId) => {
    const stateData = {
        type: UserReports_1.ReportType.REPORT,
        reportId,
        id,
        reportName,
        description,
        name,
    };
    const recentlyViewedData = new UserStoreItemBuilder_1.default()
        .addReportData(stateData)
        .addStatus(UserReports_1.RequestStatus.READY)
        .addTimestamp()
        .addReportUrls(req)
        .build();
    await services.recentlyViewedService.setRecentlyViewed(recentlyViewedData, userId);
};
const getReportData = async ({ services, req, token, reportId, id, }) => {
    const { dataProductDefinitionsPath } = req.query;
    const reportDefinition = await services.reportingService.getDefinition(token, reportId, id, dataProductDefinitionsPath);
    const { variant } = reportDefinition;
    const { resourceName, specification } = variant;
    const reportQuery = new ReportQuery_1.default({
        fields: specification.fields,
        template: specification.template,
        queryParams: req.query,
        definitionsPath: dataProductDefinitionsPath,
    });
    return {
        reportData: await services.reportingService.getListWithWarnings(resourceName, token, reportQuery),
        reportDefinition,
        reportQuery,
    };
};
const getReport = async ({ req, res, services }) => {
    const { token, csrfToken, userId } = localsHelper_1.default.getValues(res);
    const { reportId, id } = req.params;
    const { dataProductDefinitionsPath } = req.query;
    const { reportData, reportDefinition, reportQuery } = await getReportData({ services, req, token, reportId, id });
    const count = await services.reportingService.getCount(reportDefinition.variant.resourceName, token, reportQuery);
    const canDownload = await services.downloadPermissionService.downloadEnabled(userId, reportId, id);
    const bookmarked = await services.bookmarkService.isBookmarked(id, reportId, userId);
    const renderData = await getRenderData({
        req,
        reportDefinition,
        reportQuery,
        reportData,
        count,
        csrfToken,
        canDownload,
    });
    if (Object.keys(renderData).length) {
        setAsRecentlyViewed(req, services, reportId, id, renderData.reportName, renderData.name, renderData.description, userId);
    }
    return {
        renderData: {
            ...renderData,
            csrfToken,
            loadType: UserReports_1.LoadType.SYNC,
            reportId,
            id,
            bookmarked,
            dataProductDefinitionsPath,
        },
    };
};
const getReportRenderData = async (req, count, specification, reportQuery, data) => {
    const url = (0, parseurl_1.default)(req);
    const fullUrl = `${req.protocol}://${req.get('host')}${req.originalUrl}`;
    const pagination = utils_1.default.getPaginationData(url, count);
    const dataTable = new DataTableBuilder_1.default(specification.fields)
        .withHeaderSortOptions(reportQuery)
        .buildTable(data);
    const totals = utils_2.default.getTotals(pagination.pageSize, pagination.currentPage, pagination.totalRows, dataTable.rowCount);
    const filterData = await utils_5.default.getFilters({
        fields: specification.fields,
        req,
    });
    const columns = utils_3.default.getColumns(specification, reportQuery.columns);
    return {
        dataTable: [dataTable],
        totals,
        filterData,
        columns,
        pagination,
        reportUrl: url.pathname.replace('/download-disabled', '').replace('/download-disabled?', ''),
        reportSearch: url.search,
        encodedSearch: url.search ? encodeURIComponent(url.search) : undefined,
        fullUrl,
    };
};
const getRenderData = async ({ req, reportDefinition, reportQuery, reportData, count, csrfToken, canDownload, }) => {
    const { dataProductDefinitionsPath } = req.query;
    const { name: reportName, description: reportDescription } = reportDefinition;
    const { specification, name, description, classification, printable } = reportDefinition.variant;
    const { data } = reportData;
    const reportRenderData = await getReportRenderData(req, count, specification, reportQuery, data);
    const actions = setActions(csrfToken, reportDefinition, reportRenderData.columns, `${req.protocol}://${req.get('host')}${req.originalUrl}`, canDownload, count, dataProductDefinitionsPath, reportRenderData.reportUrl, reportRenderData.reportSearch);
    return {
        ...reportRenderData,
        reportName,
        name,
        description: description || reportDescription,
        count,
        type: UserReports_1.ReportType.REPORT,
        classification,
        printable,
        actions,
        warnings: reportData.warnings,
    };
};
exports.default = {
    getRenderData,
    getReport,
    getReportData,
    getReportRenderData,
    setActions,
};