uptime-kuma/server/routers/api-router.js

192 lines
4.7 KiB
JavaScript
Raw Normal View History

2021-09-13 23:55:45 -07:00
let express = require("express");
2021-09-14 23:34:30 -07:00
const { allowDevAllOrigin, getSettings, setting } = require("../util-server");
2021-09-13 23:55:45 -07:00
const { R } = require("redbean-node");
2021-09-15 05:40:26 -07:00
const server = require("../server");
const apicache = require("../modules/apicache");
2021-09-22 00:10:08 -07:00
const Monitor = require("../model/monitor");
2021-09-30 09:09:43 -07:00
const dayjs = require("dayjs");
const { UP } = require("../../src/util");
2021-09-13 23:55:45 -07:00
let router = express.Router();
let cache = apicache.middleware;
2021-09-30 09:09:43 -07:00
let io = server.io;
2021-09-15 05:40:26 -07:00
router.get("/api/entry-page", async (_, response) => {
allowDevAllOrigin(response);
response.json(server.entryPage);
});
2021-09-30 09:09:43 -07:00
router.get("/api/push/:pushToken", async (request, response) => {
try {
let pushToken = request.params.pushToken;
let msg = request.query.msg || "OK";
2021-10-01 01:43:11 -07:00
let ping = request.query.ping;
2021-09-30 09:09:43 -07:00
let monitor = await R.findOne("monitor", " push_token = ? AND active = 1 ", [
pushToken
]);
if (! monitor) {
throw new Error("Monitor not found or not active.");
}
let bean = R.dispense("heartbeat");
bean.monitor_id = monitor.id;
bean.time = R.isoDateTime(dayjs.utc());
bean.status = UP;
bean.msg = msg;
2021-10-01 01:43:11 -07:00
bean.ping = ping;
2021-09-30 09:26:27 -07:00
2021-09-30 09:09:43 -07:00
await R.store(bean);
io.to(monitor.user_id).emit("heartbeat", bean.toJSON());
Monitor.sendStats(io, monitor.id, monitor.user_id);
response.json({
ok: true,
});
} catch (e) {
response.json({
ok: false,
msg: e.message
});
}
});
2021-09-13 23:55:45 -07:00
// Status Page Config
router.get("/api/status-page/config", async (_request, response) => {
allowDevAllOrigin(response);
2021-09-14 23:34:30 -07:00
2021-09-20 05:44:07 -07:00
let config = await getSettings("statusPage");
2021-09-13 23:55:45 -07:00
if (! config.statusPageTheme) {
config.statusPageTheme = "light";
}
2021-09-14 23:34:30 -07:00
if (! config.statusPagePublished) {
config.statusPagePublished = true;
}
2021-09-14 08:27:11 -07:00
if (! config.title) {
config.title = "Uptime Kuma";
}
2021-09-13 23:55:45 -07:00
response.json(config);
});
2021-09-14 23:34:30 -07:00
// Status Page - Get the current Incident
// Can fetch only if published
router.get("/api/status-page/incident", async (_, response) => {
allowDevAllOrigin(response);
try {
await checkPublished();
let incident = await R.findOne("incident", " pin = 1 AND active = 1");
if (incident) {
incident = incident.toPublicJSON();
}
2021-09-16 07:48:28 -07:00
response.json({
ok: true,
incident,
});
2021-09-14 23:34:30 -07:00
} catch (error) {
send403(response, error.message);
}
});
2021-09-13 23:55:45 -07:00
// Status Page - Monitor List
2021-09-14 23:34:30 -07:00
// Can fetch only if published
router.get("/api/status-page/monitor-list", cache("5 minutes"), async (_request, response) => {
2021-09-13 23:55:45 -07:00
allowDevAllOrigin(response);
2021-09-14 23:34:30 -07:00
try {
await checkPublished();
const publicGroupList = [];
let list = await R.find("group", " public = 1 ORDER BY weight ");
2021-09-13 23:55:45 -07:00
for (let groupBean of list) {
publicGroupList.push(await groupBean.toPublicJSON());
2021-09-14 23:34:30 -07:00
}
response.json(publicGroupList);
2021-09-13 23:55:45 -07:00
2021-09-14 23:34:30 -07:00
} catch (error) {
send403(response, error.message);
}
2021-09-13 23:55:45 -07:00
});
// Status Page Polling Data
2021-09-14 23:34:30 -07:00
// Can fetch only if published
router.get("/api/status-page/heartbeat", cache("5 minutes"), async (_request, response) => {
2021-09-13 23:55:45 -07:00
allowDevAllOrigin(response);
2021-09-23 03:45:30 -07:00
2021-09-14 23:34:30 -07:00
try {
await checkPublished();
2021-09-13 23:55:45 -07:00
let heartbeatList = {};
2021-09-22 00:10:08 -07:00
let uptimeList = {};
let monitorIDList = await R.getCol(`
SELECT monitor_group.monitor_id FROM monitor_group, \`group\`
WHERE monitor_group.group_id = \`group\`.id
AND public = 1
`);
for (let monitorID of monitorIDList) {
let list = await R.getAll(`
SELECT * FROM heartbeat
WHERE monitor_id = ?
ORDER BY time DESC
2021-09-22 00:10:08 -07:00
LIMIT 50
`, [
monitorID,
]);
list = R.convertToBeans("heartbeat", list);
heartbeatList[monitorID] = list.reverse().map(row => row.toPublicJSON());
2021-09-22 00:10:08 -07:00
const type = 24;
uptimeList[`${monitorID}_${type}`] = await Monitor.calcUptime(type, monitorID);
2021-09-14 23:34:30 -07:00
}
response.json({
heartbeatList,
2021-09-22 00:10:08 -07:00
uptimeList
2021-09-14 23:34:30 -07:00
});
2021-09-13 23:55:45 -07:00
2021-09-14 23:34:30 -07:00
} catch (error) {
send403(response, error.message);
}
2021-09-13 23:55:45 -07:00
});
2021-09-14 23:34:30 -07:00
async function checkPublished() {
if (! await isPublished()) {
throw new Error("The status page is not published");
}
}
2021-09-15 03:28:48 -07:00
/**
* Default is published
* @returns {Promise<boolean>}
*/
2021-09-14 23:34:30 -07:00
async function isPublished() {
2021-09-15 03:28:48 -07:00
const value = await setting("statusPagePublished");
if (value === null) {
return true;
}
return value;
2021-09-14 23:34:30 -07:00
}
function send403(res, msg = "") {
res.status(403).json({
"status": "fail",
"msg": msg,
});
2021-09-14 23:34:30 -07:00
}
2021-09-13 23:55:45 -07:00
module.exports = router;