uptime-kuma/server/model/status_page.js

308 lines
8.8 KiB
JavaScript
Raw Normal View History

2022-03-10 08:34:30 -05:00
const { BeanModel } = require("redbean-node/dist/bean-model");
const { R } = require("redbean-node");
2022-05-10 12:51:11 -04:00
const cheerio = require("cheerio");
2022-05-30 03:45:44 -04:00
const { UptimeKumaServer } = require("../uptime-kuma-server");
2022-10-07 03:02:19 -04:00
const jsesc = require("jsesc");
const Maintenance = require("./maintenance");
2022-03-10 08:34:30 -05:00
class StatusPage extends BeanModel {
2022-05-30 03:45:44 -04:00
/**
* Like this: { "test-uptime.kuma.pet": "default" }
* @type {{}}
*/
2022-04-06 10:43:22 -04:00
static domainMappingList = { };
2022-05-30 03:45:44 -04:00
/**
*
* @param {Response} response
* @param {string} indexHTML
* @param {string} slug
*/
static async handleStatusPageResponse(response, indexHTML, slug) {
let statusPage = await R.findOne("status_page", " slug = ? ", [
slug
]);
if (statusPage) {
2022-06-01 01:05:12 -04:00
response.send(await StatusPage.renderHTML(indexHTML, statusPage));
2022-05-30 03:45:44 -04:00
} else {
response.status(404).send(UptimeKumaServer.getInstance().indexHTML);
}
}
2022-05-10 12:51:11 -04:00
/**
* SSR for status pages
* @param {string} indexHTML
* @param {StatusPage} statusPage
*/
2022-06-01 01:05:12 -04:00
static async renderHTML(indexHTML, statusPage) {
2022-05-10 12:51:11 -04:00
const $ = cheerio.load(indexHTML);
const description155 = statusPage.description?.substring(0, 155) ?? "";
2022-05-10 12:51:11 -04:00
2022-05-30 03:45:44 -04:00
$("title").text(statusPage.title);
2022-05-31 10:53:48 -04:00
$("meta[name=description]").attr("content", description155);
2022-05-30 03:45:44 -04:00
if (statusPage.icon) {
$("link[rel=icon]")
.attr("href", statusPage.icon)
.removeAttr("type");
$("link[rel=apple-touch-icon]").remove();
2022-05-30 03:45:44 -04:00
}
const head = $("head");
2022-05-31 10:53:48 -04:00
// OG Meta Tags
head.append(`<meta property="og:title" content="${statusPage.title}" />`);
head.append(`<meta property="og:description" content="${description155}" />`);
2022-06-01 01:05:12 -04:00
// Preload data
2022-10-07 03:02:19 -04:00
// Add jsesc, fix https://github.com/louislam/uptime-kuma/issues/2186
2022-10-09 14:47:24 -04:00
const escapedJSONObject = jsesc(await StatusPage.getStatusPageData(statusPage), {
2022-10-07 03:02:19 -04:00
"isScriptContext": true
});
const script = $(`
<script id="preload-data" data-json="{}">
window.preloadData = ${escapedJSONObject};
2022-06-01 01:05:12 -04:00
</script>
`);
2022-10-07 03:02:19 -04:00
head.append(script);
// manifest.json
$("link[rel=manifest]").attr("href", `/api/status-page/${statusPage.slug}/manifest.json`);
2022-05-10 12:51:11 -04:00
return $.root().html();
}
2022-06-01 01:05:12 -04:00
/**
* Get all status page data in one call
* @param {StatusPage} statusPage
*/
static async getStatusPageData(statusPage) {
// Incident
let incident = await R.findOne("incident", " pin = 1 AND active = 1 AND status_page_id = ? ", [
statusPage.id,
]);
if (incident) {
incident = incident.toPublicJSON();
}
let maintenanceList = await StatusPage.getMaintenanceList(statusPage.id);
2022-06-01 01:05:12 -04:00
// Public Group List
const publicGroupList = [];
const showTags = !!statusPage.show_tags;
const list = await R.find("group", " public = 1 AND status_page_id = ? ORDER BY weight ", [
statusPage.id
]);
for (let groupBean of list) {
let monitorGroup = await groupBean.toPublicJSON(showTags);
publicGroupList.push(monitorGroup);
}
// Response
return {
config: await statusPage.toPublicJSON(),
incident,
publicGroupList,
maintenanceList,
2022-06-01 01:05:12 -04:00
};
}
2022-04-06 10:43:22 -04:00
/**
* Loads domain mapping from DB
2022-04-06 10:43:22 -04:00
* Return object like this: { "test-uptime.kuma.pet": "default" }
* @returns {Promise<void>}
*/
static async loadDomainMappingList() {
2022-04-09 12:25:27 -04:00
StatusPage.domainMappingList = await R.getAssoc(`
2022-04-06 10:43:22 -04:00
SELECT domain, slug
FROM status_page, status_page_cname
WHERE status_page.id = status_page_cname.status_page_id
`);
}
/**
* Send status page list to client
* @param {Server} io io Socket server instance
* @param {Socket} socket Socket.io instance
* @returns {Promise<Bean[]>}
*/
2022-03-10 08:34:30 -05:00
static async sendStatusPageList(io, socket) {
let result = {};
let list = await R.findAll("status_page", " ORDER BY title ");
for (let item of list) {
result[item.id] = await item.toJSON();
}
io.to(socket.userID).emit("statusPageList", result);
return list;
}
/**
* Update list of domain names
* @param {string[]} domainNameList
* @returns {Promise<void>}
*/
2022-04-09 12:25:27 -04:00
async updateDomainNameList(domainNameList) {
if (!Array.isArray(domainNameList)) {
throw new Error("Invalid array");
}
let trx = await R.begin();
await trx.exec("DELETE FROM status_page_cname WHERE status_page_id = ?", [
this.id,
]);
try {
for (let domain of domainNameList) {
if (typeof domain !== "string") {
throw new Error("Invalid domain");
}
if (domain.trim() === "") {
continue;
}
// If the domain name is used in another status page, delete it
await trx.exec("DELETE FROM status_page_cname WHERE domain = ?", [
domain,
]);
let mapping = trx.dispense("status_page_cname");
mapping.status_page_id = this.id;
mapping.domain = domain;
await trx.store(mapping);
}
await trx.commit();
} catch (error) {
await trx.rollback();
throw error;
}
}
/**
* Get list of domain names
* @returns {Object[]}
*/
2022-04-09 12:25:27 -04:00
getDomainNameList() {
2022-04-06 10:43:22 -04:00
let domainList = [];
for (let domain in StatusPage.domainMappingList) {
let s = StatusPage.domainMappingList[domain];
if (this.slug === s) {
domainList.push(domain);
}
}
return domainList;
}
/**
* Return an object that ready to parse to JSON
* @returns {Object}
*/
2022-03-10 08:34:30 -05:00
async toJSON() {
return {
id: this.id,
slug: this.slug,
title: this.title,
2022-03-16 02:14:47 -04:00
description: this.description,
icon: this.getIcon(),
2022-03-10 08:34:30 -05:00
theme: this.theme,
published: !!this.published,
showTags: !!this.show_tags,
2022-04-09 12:25:27 -04:00
domainNameList: this.getDomainNameList(),
customCSS: this.custom_css,
footerText: this.footer_text,
showPoweredBy: !!this.show_powered_by,
2022-03-10 08:34:30 -05:00
};
}
/**
* Return an object that ready to parse to JSON for public
* Only show necessary data to public
* @returns {Object}
*/
2022-03-10 08:34:30 -05:00
async toPublicJSON() {
return {
slug: this.slug,
title: this.title,
2022-03-16 02:14:47 -04:00
description: this.description,
icon: this.getIcon(),
2022-03-10 08:34:30 -05:00
theme: this.theme,
published: !!this.published,
showTags: !!this.show_tags,
customCSS: this.custom_css,
footerText: this.footer_text,
showPoweredBy: !!this.show_powered_by,
2022-03-10 08:34:30 -05:00
};
}
/**
* Convert slug to status page ID
* @param {string} slug
*/
static async slugToID(slug) {
return await R.getCell("SELECT id FROM status_page WHERE slug = ? ", [
slug
]);
}
/**
* Get path to the icon for the page
* @returns {string}
*/
getIcon() {
if (!this.icon) {
return "/icon.svg";
} else {
return this.icon;
}
}
/**
* Get list of maintenances
* @param {number} statusPageId ID of status page to get maintenance for
* @returns {Object} Object representing maintenances sanitized for public
*/
static async getMaintenanceList(statusPageId) {
try {
const publicMaintenanceList = [];
let activeCondition = Maintenance.getActiveMaintenanceSQLCondition();
let maintenanceBeanList = R.convertToBeans("maintenance", await R.getAll(`
SELECT maintenance.*
FROM maintenance
JOIN maintenance_status_page
ON maintenance_status_page.maintenance_id = maintenance.id
AND maintenance_status_page.status_page_id = ?
LEFT JOIN maintenance_timeslot
ON maintenance_timeslot.maintenance_id = maintenance.id
WHERE ${activeCondition}
ORDER BY maintenance.end_date
`, [ statusPageId ]));
for (const bean of maintenanceBeanList) {
publicMaintenanceList.push(await bean.toPublicJSON());
}
return publicMaintenanceList;
} catch (error) {
return [];
}
}
2022-03-10 08:34:30 -05:00
}
module.exports = StatusPage;