@ministryofjustice/hmpps-digital-prison-reporting-frontend/dpr/components/report-list/utils.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 });
exports.renderListWithDefinition = void 0;
exports.renderList = renderList;
const ReportQuery_1 = __importDefault(require("../../types/ReportQuery"));
const reportingClient_1 = __importDefault(require("../../data/reportingClient"));
const utils_1 = __importDefault(require("../_reports/report-actions/utils"));
const syncReportUtils_1 = __importDefault(require("../../utils/report/syncReportUtils"));
const utils_2 = __importDefault(require("../_filters/utils"));
const UserReports_1 = require("../../types/UserReports");
function isListWithWarnings(data) {
    return data.data !== undefined;
}
async function renderList(listData, variantDefinition, reportQuery, request, response, next, title, layoutTemplate, otherOptions, reportName) {
    await Promise.all([listData.data, listData.count])
        .then(async (resolvedData) => {
        let data;
        let warnings = {};
        const { specification, classification, printable, description, name: variantName } = variantDefinition;
        const { template } = specification;
        const count = resolvedData[1];
        if (isListWithWarnings(resolvedData[0])) {
            // eslint-disable-next-line prefer-destructuring
            data = resolvedData[0].data;
            warnings = resolvedData[0].warnings;
        }
        else {
            // eslint-disable-next-line prefer-destructuring
            data = resolvedData[0];
        }
        const reportRenderData = await syncReportUtils_1.default.getReportRenderData(request, count, specification, reportQuery, data);
        const actions = utils_1.default.getActions({
            print: {
                enabled: variantDefinition.printable,
            },
            share: {
                reportName,
                name: variantDefinition.name,
                url: reportRenderData.fullUrl,
            },
            copy: {
                url: reportRenderData.fullUrl,
            },
        });
        const renderData = {
            renderData: {
                ...reportRenderData,
                reportName,
                name: title || variantName,
                description,
                count,
                classification,
                printable,
                actions,
                template,
                warnings,
                type: UserReports_1.ReportType.REPORT,
                ...otherOptions,
            },
            layoutTemplate,
        };
        response.render(`dpr/components/report-list/list`, renderData);
    })
        .catch((err) => next(err));
}
const renderListWithDefinition = async ({ title, definitionName, variantName, request, response, next, otherOptions, layoutTemplate, token, apiUrl, apiTimeout, definitionsPath, }) => {
    const reportingClient = new reportingClient_1.default({
        url: apiUrl,
        agent: {
            timeout: apiTimeout,
        },
    });
    const { dataProductDefinitionsPath } = request.query;
    const reportDef = dataProductDefinitionsPath || definitionsPath;
    try {
        const reportDefinition = await reportingClient.getDefinition(token, definitionName, variantName, reportDef);
        const reportName = reportDefinition.name;
        const variantDefinition = reportDefinition.variant;
        const reportQuery = new ReportQuery_1.default({
            fields: variantDefinition.specification.fields,
            template: variantDefinition.specification.template,
            queryParams: request.query,
            definitionsPath: reportDef,
        });
        if (!utils_2.default.redirectWithDefaultFilters(reportQuery, variantDefinition, response, request)) {
            const getListData = {
                data: reportingClient.getListWithWarnings(variantDefinition.resourceName, token, reportQuery),
                count: reportingClient.getCount(variantDefinition.resourceName, token, reportQuery),
            };
            await renderList(getListData, variantDefinition, reportQuery, request, response, next, `${variantDefinition.name}`, layoutTemplate, otherOptions, title || `${reportName}`);
        }
    }
    catch (error) {
        next(error);
    }
};
exports.renderListWithDefinition = renderListWithDefinition;
exports.default = {
    renderListWithData: async ({ title, reportName, variantDefinition, request, response, next, getListDataSources, otherOptions, layoutTemplate, }) => {
        const { specification } = variantDefinition;
        const reportQuery = new ReportQuery_1.default({
            fields: specification.fields,
            template: specification.template,
            queryParams: request.query,
            definitionsPath: request.query.dataProductDefinitionsPath,
        });
        const listData = getListDataSources(reportQuery);
        await renderList(listData, variantDefinition, reportQuery, request, response, next, title, layoutTemplate, otherOptions, reportName);
    },
    createReportListRequestHandler: ({ title, definitionName, variantName, apiUrl, apiTimeout, otherOptions, layoutTemplate, tokenProvider, definitionsPath, }) => {
        return (request, response, next) => {
            (0, exports.renderListWithDefinition)({
                title,
                definitionName,
                variantName,
                request,
                response,
                next,
                otherOptions,
                layoutTemplate,
                token: tokenProvider(request, response, next),
                apiUrl,
                apiTimeout,
                definitionsPath,
            });
        };
    },
    renderListWithDefinition: exports.renderListWithDefinition,
};