@ministryofjustice/hmpps-digital-prison-reporting-frontend
Version:
The Digital Prison Reporting Frontend contains templates and code to help display data effectively in UI applications.
151 lines (150 loc) • 6.51 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.formatBookmark = exports.formatBookmarks = void 0;
const UserReports_1 = require("../../../types/UserReports");
const utils_1 = __importDefault(require("../../show-more/utils"));
const logger_1 = __importDefault(require("../../../utils/logger"));
const definitionUtils_1 = __importDefault(require("../../../utils/definitionUtils"));
const reportListsHelper_1 = require("../../../utils/reportListsHelper");
const localsHelper_1 = __importDefault(require("../../../utils/localsHelper"));
const formatBookmarks = async (bookmarksData) => {
return bookmarksData
.map((report) => {
return (0, exports.formatBookmark)(report);
})
.sort((a, b) => a.text.localeCompare(b.text));
};
exports.formatBookmarks = formatBookmarks;
const formatBookmark = (bookmarkData) => {
const reportData = JSON.parse(JSON.stringify(bookmarkData));
const { id, name, description, href, reportName, type } = reportData;
return {
id,
reportName,
text: name,
description,
href,
type: type,
};
};
exports.formatBookmark = formatBookmark;
const formatTable = async (bookmarksData, bookmarkService, csrfToken, userId, maxRows) => {
const rows = await Promise.all(bookmarksData
.sort((a, b) => a.name.localeCompare(b.name))
.map(async (bookmark) => {
return formatTableData(bookmark, bookmarkService, csrfToken, userId);
}));
return {
rows: maxRows ? rows.slice(0, maxRows) : rows,
head: [
{ text: 'Product', classes: 'dpr-req-product-head' },
{ text: 'Description', classes: 'dpr-bm-description-head' },
{ text: 'Actions', classes: 'dpr-bm-actions-head' },
],
};
};
const formatTableData = async (bookmarksData, bookmarkService, csrfToken, userId) => {
const { description, reportName, reportId, id, href, name, type, loadType } = bookmarksData;
const bookmarkHtml = await bookmarkService.createBookMarkToggleHtml({
userId,
reportId,
id,
csrfToken,
ctxId: 'bookmark-list',
reportType: type,
});
return [
{
html: (0, reportListsHelper_1.createListItemProduct)(reportName, name, type),
},
{ html: utils_1.default.createShowMoreHtml(description), classes: 'dpr-req-cell' },
{
html: (0, reportListsHelper_1.createListActions)(href, type, loadType, bookmarkHtml),
classes: 'dpr-req-cell dpr-req-cell__status',
},
];
};
const mapBookmarkIdsToDefinition = async (bookmarks, req, res, token, services) => {
const bookmarkData = [];
const { definitionsPath } = localsHelper_1.default.getValues(res);
await Promise.all(bookmarks.map(async (bookmark) => {
var _a;
let definition;
const { reportId, variantId, id, automatic, type } = bookmark;
const bookmarkId = variantId || id;
const reportType = type ? type : UserReports_1.ReportType.REPORT;
try {
let name;
let description;
let reportName;
let loadType = UserReports_1.LoadType.ASYNC;
let href = `/async/${reportType}/${reportId}/${bookmarkId}/request`;
if (reportType === UserReports_1.ReportType.REPORT) {
definition = await services.reportingService.getDefinition(token, reportId, bookmarkId, definitionsPath);
reportName = definition.name;
name = definition.variant.name;
description = definition.variant.description || definition.description;
loadType = definition.variant.loadType || loadType;
href = (0, reportListsHelper_1.setInitialHref)(loadType, reportType, reportId, bookmarkId, res);
}
if (reportType === UserReports_1.ReportType.DASHBOARD) {
const reportDefinition = await definitionUtils_1.default.getReportSummary(reportId, services.reportingService, token, definitionsPath);
definition = await services.dashboardService.getDefinition(token, bookmarkId, reportId, definitionsPath);
name = definition.name;
reportName = reportDefinition.name;
description = definition.description;
}
if (definition) {
bookmarkData.push({
reportId,
id: bookmarkId,
reportName,
name,
description,
type: reportType,
href,
loadType,
automatic,
});
}
}
catch (error) {
// DPD has been deleted so API throws error
logger_1.default.warn(`Failed to map bookmark for: Report ${reportId}, variant ${bookmarkId}`);
const userId = ((_a = res.locals.user) === null || _a === void 0 ? void 0 : _a.uuid) ? res.locals.user.uuid : 'userId';
await services.bookmarkService.removeBookmark(userId, bookmarkId, reportId);
}
}));
return bookmarkData;
};
exports.default = {
renderBookmarkList: async ({ services, maxRows, res, req, }) => {
const { token, csrfToken, userId, bookmarks } = localsHelper_1.default.getValues(res);
const bookmarksData = await mapBookmarkIdsToDefinition(bookmarks, req, res, token, services);
let formatted = await (0, exports.formatBookmarks)(bookmarksData);
const formattedCount = formatted.length;
if (maxRows)
formatted = formatted.slice(0, maxRows);
const tableData = await formatTable(bookmarksData, services.bookmarkService, csrfToken, userId, maxRows);
const head = {
...(formatted.length && { href: './async-reports/bookmarks' }),
...(!formatted.length && { emptyMessage: 'You have 0 bookmarked reports' }),
};
const total = {
amount: formattedCount,
shown: formattedCount > maxRows ? maxRows : formattedCount,
max: maxRows,
};
const result = {
head,
tableData,
total,
csrfToken,
type: 'bookmark',
};
return result;
},
};