Merge remote-tracking branch 'origin/master' into feature/482-add-description-to-monitor

# Conflicts:
#	server/database.js
#	server/model/monitor.js
#	src/icon.js
#	src/languages/en.js
#	src/languages/es-ES.js

server/2fa.js

@@ -1,8 +1,12 @@
-const { checkLogin } = require("./util-server");
 const { R } = require("redbean-node");
 
 class TwoFA {
 
+    /**
+     * Disable 2FA for specified user
+     * @param {number} userID ID of user to disable
+     * @returns {Promise<void>}
+     */
     static async disable2FA(userID) {
         return await R.exec("UPDATE `user` SET twofa_status = 0 WHERE id = ? ", [
             userID,

server/auth.js

@@ -2,16 +2,19 @@ const basicAuth = require("express-basic-auth");
 const passwordHash = require("./password-hash");
 const { R } = require("redbean-node");
 const { setting } = require("./util-server");
-const { debug } = require("../src/util");
 const { loginRateLimiter } = require("./rate-limiter");
 
 /**
- *
- * @param username : string
- * @param password : string
- * @returns {Promise<Bean|null>}
+ * Login to web app
+ * @param {string} username
+ * @param {string} password
+ * @returns {Promise<(Bean|null)>}
  */
 exports.login = async function (username, password) {
+    if (typeof username !== "string" || typeof password !== "string") {
+        return null;
+    }
+
     let user = await R.findOne("user", " username = ? AND active = 1 ", [
         username,
     ]);
@@ -30,32 +33,54 @@ exports.login = async function (username, password) {
     return null;
 };
 
-function myAuthorizer(username, password, callback) {
-    setting("disableAuth").then((result) => {
-        if (result) {
-            callback(null, true);
-        } else {
-            // Login Rate Limit
-            loginRateLimiter.pass(null, 0).then((pass) => {
-                if (pass) {
-                    exports.login(username, password).then((user) => {
-                        callback(null, user != null);
+/**
+ * Callback for myAuthorizer
+ * @callback myAuthorizerCB
+ * @param {any} err Any error encountered
+ * @param {boolean} authorized Is the client authorized?
+ */
 
-                        if (user == null) {
-                            loginRateLimiter.removeTokens(1);
-                        }
-                    });
-                } else {
-                    callback(null, false);
+/**
+ * Custom authorizer for express-basic-auth
+ * @param {string} username
+ * @param {string} password
+ * @param {myAuthorizerCB} callback
+ */
+function myAuthorizer(username, password, callback) {
+    // Login Rate Limit
+    loginRateLimiter.pass(null, 0).then((pass) => {
+        if (pass) {
+            exports.login(username, password).then((user) => {
+                callback(null, user != null);
+
+                if (user == null) {
+                    loginRateLimiter.removeTokens(1);
                 }
             });
-
+        } else {
+            callback(null, false);
         }
     });
 }
 
-exports.basicAuth = basicAuth({
-    authorizer: myAuthorizer,
-    authorizeAsync: true,
-    challenge: true,
-});
+/**
+ * Use basic auth if auth is not disabled
+ * @param {express.Request} req Express request object
+ * @param {express.Response} res Express response object
+ * @param {express.NextFunction} next
+ */
+exports.basicAuth = async function (req, res, next) {
+    const middleware = basicAuth({
+        authorizer: myAuthorizer,
+        authorizeAsync: true,
+        challenge: true,
+    });
+
+    const disabledAuth = await setting("disableAuth");
+
+    if (!disabledAuth) {
+        middleware(req, res, next);
+    } else {
+        next();
+    }
+};

server/cacheable-dns-http-agent.js

@@ -0,0 +1,86 @@
+const https = require("https");
+const http = require("http");
+const CacheableLookup = require("cacheable-lookup");
+const { Settings } = require("./settings");
+const { log } = require("../src/util");
+
+class CacheableDnsHttpAgent {
+
+    static cacheable = new CacheableLookup();
+
+    static httpAgentList = {};
+    static httpsAgentList = {};
+
+    static enable = false;
+
+    /**
+     * Register/Disable cacheable to global agents
+     */
+    static async update() {
+        log.debug("CacheableDnsHttpAgent", "update");
+        let isEnable = await Settings.get("dnsCache");
+
+        if (isEnable !== this.enable) {
+            log.debug("CacheableDnsHttpAgent", "value changed");
+
+            if (isEnable) {
+                log.debug("CacheableDnsHttpAgent", "enable");
+                this.cacheable.install(http.globalAgent);
+                this.cacheable.install(https.globalAgent);
+            } else {
+                log.debug("CacheableDnsHttpAgent", "disable");
+                this.cacheable.uninstall(http.globalAgent);
+                this.cacheable.uninstall(https.globalAgent);
+            }
+        }
+
+        this.enable = isEnable;
+    }
+
+    /**
+     * Attach cacheable to HTTP agent
+     * @param {http.Agent} agent Agent to install
+     */
+    static install(agent) {
+        this.cacheable.install(agent);
+    }
+
+    /**
+     * @var {https.AgentOptions} agentOptions
+     * @return {https.Agent}
+     */
+    static getHttpsAgent(agentOptions) {
+        if (!this.enable) {
+            return new https.Agent(agentOptions);
+        }
+
+        let key = JSON.stringify(agentOptions);
+        if (!(key in this.httpsAgentList)) {
+            this.httpsAgentList[key] = new https.Agent(agentOptions);
+            this.cacheable.install(this.httpsAgentList[key]);
+        }
+        return this.httpsAgentList[key];
+    }
+
+    /**
+     * @var {http.AgentOptions} agentOptions
+     * @return {https.Agents}
+     */
+    static getHttpAgent(agentOptions) {
+        if (!this.enable) {
+            return new http.Agent(agentOptions);
+        }
+
+        let key = JSON.stringify(agentOptions);
+        if (!(key in this.httpAgentList)) {
+            this.httpAgentList[key] = new http.Agent(agentOptions);
+            this.cacheable.install(this.httpAgentList[key]);
+        }
+        return this.httpAgentList[key];
+    }
+
+}
+
+module.exports = {
+    CacheableDnsHttpAgent,
+};

server/check-version.js

@@ -1,11 +1,13 @@
-const { setSetting } = require("./util-server");
+const { setSetting, setting } = require("./util-server");
 const axios = require("axios");
+const compareVersions = require("compare-versions");
 
 exports.version = require("../package.json").version;
 exports.latestVersion = null;
 
 let interval;
 
+/** Start 48 hour check interval */
 exports.startInterval = () => {
     let check = async () => {
         try {
@@ -16,6 +18,19 @@ exports.startInterval = () => {
                 res.data.slow = "1000.0.0";
             }
 
+            if (await setting("checkUpdate") === false) {
+                return;
+            }
+
+            let checkBeta = await setting("checkBeta");
+
+            if (checkBeta && res.data.beta) {
+                if (compareVersions.compare(res.data.beta, res.data.slow, ">")) {
+                    exports.latestVersion = res.data.beta;
+                    return;
+                }
+            }
+
             if (res.data.slow) {
                 exports.latestVersion = res.data.slow;
             }
@@ -28,6 +43,11 @@ exports.startInterval = () => {
     interval = setInterval(check, 3600 * 1000 * 48);
 };
 
+/**
+ * Enable the check update feature
+ * @param {boolean} value Should the check update feature be enabled?
+ * @returns {Promise<void>}
+ */
 exports.enableCheckUpdate = async (value) => {
     await setSetting("checkUpdate", value);
 

server/client.js

@@ -3,10 +3,17 @@
  */
 const { TimeLogger } = require("../src/util");
 const { R } = require("redbean-node");
-const { io } = require("./server");
+const { UptimeKumaServer } = require("./uptime-kuma-server");
+const server = UptimeKumaServer.getInstance();
+const io = server.io;
 const { setting } = require("./util-server");
 const checkVersion = require("./check-version");
 
+/**
+ * Send list of notification providers to client
+ * @param {Socket} socket Socket.io socket instance
+ * @returns {Promise<Bean[]>}
+ */
 async function sendNotificationList(socket) {
     const timeLogger = new TimeLogger();
 
@@ -16,7 +23,10 @@ async function sendNotificationList(socket) {
     ]);
 
     for (let bean of list) {
-        result.push(bean.export());
+        let notificationObject = bean.export();
+        notificationObject.isDefault = (notificationObject.isDefault === 1);
+        notificationObject.active = (notificationObject.active === 1);
+        result.push(notificationObject);
     }
 
     io.to(socket.userID).emit("notificationList", result);
@@ -28,8 +38,11 @@ async function sendNotificationList(socket) {
 
 /**
  * Send Heartbeat History list to socket
- * @param toUser  True = send to all browsers with the same user id, False = send to the current browser only
- * @param overwrite Overwrite client-side's heartbeat list
+ * @param {Socket} socket Socket.io instance
+ * @param {number} monitorID ID of monitor to send heartbeat history
+ * @param {boolean} [toUser=false]  True = send to all browsers with the same user id, False = send to the current browser only
+ * @param {boolean} [overwrite=false] Overwrite client-side's heartbeat list
+ * @returns {Promise<void>}
  */
 async function sendHeartbeatList(socket, monitorID, toUser = false, overwrite = false) {
     const timeLogger = new TimeLogger();
@@ -55,11 +68,12 @@ async function sendHeartbeatList(socket, monitorID, toUser = false, overwrite =
 }
 
 /**
- *  Important Heart beat list (aka event list)
- * @param socket
- * @param monitorID
- * @param toUser  True = send to all browsers with the same user id, False = send to the current browser only
- * @param overwrite Overwrite client-side's heartbeat list
+ * Important Heart beat list (aka event list)
+ * @param {Socket} socket Socket.io instance
+ * @param {number} monitorID ID of monitor to send heartbeat history
+ * @param {boolean} [toUser=false]  True = send to all browsers with the same user id, False = send to the current browser only
+ * @param {boolean} [overwrite=false] Overwrite client-side's heartbeat list
+ * @returns {Promise<void>}
  */
 async function sendImportantHeartbeatList(socket, monitorID, toUser = false, overwrite = false) {
     const timeLogger = new TimeLogger();
@@ -83,18 +97,66 @@ async function sendImportantHeartbeatList(socket, monitorID, toUser = false, ove
 
 }
 
+/**
+ * Emit proxy list to client
+ * @param {Socket} socket Socket.io socket instance
+ * @return {Promise<Bean[]>}
+ */
+async function sendProxyList(socket) {
+    const timeLogger = new TimeLogger();
+
+    const list = await R.find("proxy", " user_id = ? ", [ socket.userID ]);
+    io.to(socket.userID).emit("proxyList", list.map(bean => bean.export()));
+
+    timeLogger.print("Send Proxy List");
+
+    return list;
+}
+
+/**
+ * Emits the version information to the client.
+ * @param {Socket} socket Socket.io socket instance
+ * @returns {Promise<void>}
+ */
 async function sendInfo(socket) {
     socket.emit("info", {
         version: checkVersion.version,
         latestVersion: checkVersion.latestVersion,
-        primaryBaseURL: await setting("primaryBaseURL")
+        primaryBaseURL: await setting("primaryBaseURL"),
+        serverTimezone: await server.getTimezone(),
+        serverTimezoneOffset: server.getTimezoneOffset(),
     });
 }
 
+/**
+ * Send list of docker hosts to client
+ * @param {Socket} socket Socket.io socket instance
+ * @returns {Promise<Bean[]>}
+ */
+async function sendDockerHostList(socket) {
+    const timeLogger = new TimeLogger();
+
+    let result = [];
+    let list = await R.find("docker_host", " user_id = ? ", [
+        socket.userID,
+    ]);
+
+    for (let bean of list) {
+        result.push(bean.toJSON());
+    }
+
+    io.to(socket.userID).emit("dockerHostList", result);
+
+    timeLogger.print("Send Docker Host List");
+
+    return list;
+}
+
 module.exports = {
     sendNotificationList,
     sendImportantHeartbeatList,
     sendHeartbeatList,
-    sendInfo
+    sendProxyList,
+    sendInfo,
+    sendDockerHostList
 };
-

server/config.js

@@ -1,7 +1,28 @@
 const args = require("args-parser")(process.argv);
 const demoMode = args["demo"] || false;
 
+const badgeConstants = {
+    naColor: "#999",
+    defaultUpColor: "#66c20a",
+    defaultWarnColor: "#eed202",
+    defaultDownColor: "#c2290a",
+    defaultPendingColor: "#f8a306",
+    defaultMaintenanceColor: "#1747f5",
+    defaultPingColor: "blue",  // as defined by badge-maker / shields.io
+    defaultStyle: "flat",
+    defaultPingValueSuffix: "ms",
+    defaultPingLabelSuffix: "h",
+    defaultUptimeValueSuffix: "%",
+    defaultUptimeLabelSuffix: "h",
+    defaultCertExpValueSuffix: " days",
+    defaultCertExpLabelSuffix: "h",
+    // Values Come From Default Notification Times
+    defaultCertExpireWarnDays: "14",
+    defaultCertExpireDownDays: "7"
+};
+
 module.exports = {
     args,
-    demoMode
+    demoMode,
+    badgeConstants,
 };

server/database.js

@@ -1,9 +1,10 @@
 const fs = require("fs");
 const { R } = require("redbean-node");
 const { setSetting, setting } = require("./util-server");
-const { debug, sleep } = require("../src/util");
+const { log, sleep } = require("../src/util");
 const dayjs = require("dayjs");
 const knex = require("knex");
+const { PluginsManager } = require("./plugins-manager");
 
 /**
  * Database & App Data Folder
@@ -53,8 +54,25 @@ class Database {
         "patch-2fa-invalidate-used-token.sql": true,
         "patch-notification_sent_history.sql": true,
         "patch-monitor-basic-auth.sql": true,
+        "patch-add-docker-columns.sql": true,
+        "patch-status-page.sql": true,
+        "patch-proxy.sql": true,
+        "patch-monitor-expiry-notification.sql": true,
+        "patch-status-page-footer-css.sql": true,
+        "patch-added-mqtt-monitor.sql": true,
+        "patch-add-clickable-status-page-link.sql": true,
+        "patch-add-sqlserver-monitor.sql": true,
+        "patch-add-other-auth.sql": { parents: [ "patch-monitor-basic-auth.sql" ] },
+        "patch-grpc-monitor.sql": true,
+        "patch-add-radius-monitor.sql": true,
+        "patch-monitor-add-resend-interval.sql": true,
+        "patch-ping-packet-size.sql": true,
+        "patch-maintenance-table2.sql": true,
+        "patch-add-gamedig-monitor.sql": true,
+        "patch-add-google-analytics-status-page-tag.sql": true,
+        "patch-http-body-encoding.sql": true,
         "patch-add-description-monitor.sql": true,
-    }
+    };
 
     /**
      * The final version should be 10 after merged tag feature
@@ -64,9 +82,20 @@ class Database {
 
     static noReject = true;
 
+    /**
+     * Initialize the database
+     * @param {Object} args Arguments to initialize DB with
+     */
     static init(args) {
         // Data Directory (must be end with "/")
         Database.dataDir = process.env.DATA_DIR || args["data-dir"] || "./data/";
+
+        // Plugin feature is working only if the dataDir = "./data";
+        if (Database.dataDir !== "./data/") {
+            log.warn("PLUGIN", "Warning: In order to enable plugin feature, you need to use the default data directory: ./data/");
+            PluginsManager.disable = true;
+        }
+
         Database.path = Database.dataDir + "kuma.db";
         if (! fs.existsSync(Database.dataDir)) {
             fs.mkdirSync(Database.dataDir, { recursive: true });
@@ -78,10 +107,19 @@ class Database {
             fs.mkdirSync(Database.uploadDir, { recursive: true });
         }
 
-        console.log(`Data Dir: ${Database.dataDir}`);
+        log.info("db", `Data Dir: ${Database.dataDir}`);
     }
 
-    static async connect(testMode = false) {
+    /**
+     * Connect to the database
+     * @param {boolean} [testMode=false] Should the connection be
+     * started in test mode?
+     * @param {boolean} [autoloadModels=true] Should models be
+     * automatically loaded?
+     * @param {boolean} [noLog=false] Should logs not be output?
+     * @returns {Promise<void>}
+     */
+    static async connect(testMode = false, autoloadModels = true, noLog = false) {
         const acquireConnectionTimeout = 120 * 1000;
 
         const Dialect = require("knex/lib/dialects/sqlite3/index.js");
@@ -111,7 +149,10 @@ class Database {
 
         // Auto map the model to a bean object
         R.freeze(true);
-        await R.autoloadModels("./server/model");
+
+        if (autoloadModels) {
+            await R.autoloadModels("./server/model");
+        }
 
         await R.exec("PRAGMA foreign_keys = ON");
         if (testMode) {
@@ -124,12 +165,20 @@ class Database {
         await R.exec("PRAGMA cache_size = -12000");
         await R.exec("PRAGMA auto_vacuum = FULL");
 
-        console.log("SQLite config:");
-        console.log(await R.getAll("PRAGMA journal_mode"));
-        console.log(await R.getAll("PRAGMA cache_size"));
-        console.log("SQLite Version: " + await R.getCell("SELECT sqlite_version()"));
+        // This ensures that an operating system crash or power failure will not corrupt the database.
+        // FULL synchronous is very safe, but it is also slower.
+        // Read more: https://sqlite.org/pragma.html#pragma_synchronous
+        await R.exec("PRAGMA synchronous = FULL");
+
+        if (!noLog) {
+            log.info("db", "SQLite config:");
+            log.info("db", await R.getAll("PRAGMA journal_mode"));
+            log.info("db", await R.getAll("PRAGMA cache_size"));
+            log.info("db", "SQLite Version: " + await R.getCell("SELECT sqlite_version()"));
+        }
     }
 
+    /** Patch the database */
     static async patch() {
         let version = parseInt(await setting("database_version"));
 
@@ -137,33 +186,39 @@ class Database {
             version = 0;
         }
 
-        console.info("Your database version: " + version);
-        console.info("Latest database version: " + this.latestVersion);
+        log.info("db", "Your database version: " + version);
+        log.info("db", "Latest database version: " + this.latestVersion);
 
         if (version === this.latestVersion) {
-            console.info("Database patch not needed");
+            log.info("db", "Database patch not needed");
         } else if (version > this.latestVersion) {
-            console.info("Warning: Database version is newer than expected");
+            log.info("db", "Warning: Database version is newer than expected");
         } else {
-            console.info("Database patch is needed");
+            log.info("db", "Database patch is needed");
 
-            this.backup(version);
+            try {
+                this.backup(version);
+            } catch (e) {
+                log.error("db", e);
+                log.error("db", "Unable to create a backup before patching the database. Please make sure you have enough space and permission.");
+                process.exit(1);
+            }
 
             // Try catch anything here, if gone wrong, restore the backup
             try {
                 for (let i = version + 1; i <= this.latestVersion; i++) {
                     const sqlFile = `./db/patch${i}.sql`;
-                    console.info(`Patching ${sqlFile}`);
+                    log.info("db", `Patching ${sqlFile}`);
                     await Database.importSQLFile(sqlFile);
-                    console.info(`Patched ${sqlFile}`);
+                    log.info("db", `Patched ${sqlFile}`);
                     await setSetting("database_version", i);
                 }
             } catch (ex) {
                 await Database.close();
 
-                console.error(ex);
-                console.error("Start Uptime-Kuma failed due to issue patching the database");
-                console.error("Please submit a bug report if you still encounter the problem after restart: https://github.com/louislam/uptime-kuma/issues");
+                log.error("db", ex);
+                log.error("db", "Start Uptime-Kuma failed due to issue patching the database");
+                log.error("db", "Please submit a bug report if you still encounter the problem after restart: https://github.com/louislam/uptime-kuma/issues");
 
                 this.restore();
                 process.exit(1);
@@ -171,22 +226,25 @@ class Database {
         }
 
         await this.patch2();
+        await this.migrateNewStatusPage();
     }
 
     /**
+     * Patch DB using new process
      * Call it from patch() only
+     * @private
      * @returns {Promise<void>}
      */
     static async patch2() {
-        console.log("Database Patch 2.0 Process");
+        log.info("db", "Database Patch 2.0 Process");
         let databasePatchedFiles = await setting("databasePatchedFiles");
 
         if (! databasePatchedFiles) {
             databasePatchedFiles = {};
         }
 
-        debug("Patched files:");
-        debug(databasePatchedFiles);
+        log.debug("db", "Patched files:");
+        log.debug("db", databasePatchedFiles);
 
         try {
             for (let sqlFilename in this.patchList) {
@@ -194,15 +252,15 @@ class Database {
             }
 
             if (this.patched) {
-                console.log("Database Patched Successfully");
+                log.info("db", "Database Patched Successfully");
             }
 
         } catch (ex) {
             await Database.close();
 
-            console.error(ex);
-            console.error("Start Uptime-Kuma failed due to issue patching the database");
-            console.error("Please submit the bug report if you still encounter the problem after restart: https://github.com/louislam/uptime-kuma/issues");
+            log.error("db", ex);
+            log.error("db", "Start Uptime-Kuma failed due to issue patching the database");
+            log.error("db", "Please submit the bug report if you still encounter the problem after restart: https://github.com/louislam/uptime-kuma/issues");
 
             this.restore();
 
@@ -213,24 +271,95 @@ class Database {
     }
 
     /**
+     * Migrate status page value in setting to "status_page" table
+     * @returns {Promise<void>}
+     */
+    static async migrateNewStatusPage() {
+
+        // Fix 1.13.0 empty slug bug
+        await R.exec("UPDATE status_page SET slug = 'empty-slug-recover' WHERE TRIM(slug) = ''");
+
+        let title = await setting("title");
+
+        if (title) {
+            console.log("Migrating Status Page");
+
+            let statusPageCheck = await R.findOne("status_page", " slug = 'default' ");
+
+            if (statusPageCheck !== null) {
+                console.log("Migrating Status Page - Skip, default slug record is already existing");
+                return;
+            }
+
+            let statusPage = R.dispense("status_page");
+            statusPage.slug = "default";
+            statusPage.title = title;
+            statusPage.description = await setting("description");
+            statusPage.icon = await setting("icon");
+            statusPage.theme = await setting("statusPageTheme");
+            statusPage.published = !!await setting("statusPagePublished");
+            statusPage.search_engine_index = !!await setting("searchEngineIndex");
+            statusPage.show_tags = !!await setting("statusPageTags");
+            statusPage.password = null;
+
+            if (!statusPage.title) {
+                statusPage.title = "My Status Page";
+            }
+
+            if (!statusPage.icon) {
+                statusPage.icon = "";
+            }
+
+            if (!statusPage.theme) {
+                statusPage.theme = "light";
+            }
+
+            let id = await R.store(statusPage);
+
+            await R.exec("UPDATE incident SET status_page_id = ? WHERE status_page_id IS NULL", [
+                id
+            ]);
+
+            await R.exec("UPDATE [group] SET status_page_id = ? WHERE status_page_id IS NULL", [
+                id
+            ]);
+
+            await R.exec("DELETE FROM setting WHERE type = 'statusPage'");
+
+            // Migrate Entry Page if it is status page
+            let entryPage = await setting("entryPage");
+
+            if (entryPage === "statusPage") {
+                await setSetting("entryPage", "statusPage-default", "general");
+            }
+
+            console.log("Migrating Status Page - Done");
+        }
+
+    }
+
+    /**
+     * Patch database using new patching process
      * Used it patch2() only
+     * @private
      * @param sqlFilename
      * @param databasePatchedFiles
+     * @returns {Promise<void>}
      */
     static async patch2Recursion(sqlFilename, databasePatchedFiles) {
         let value = this.patchList[sqlFilename];
 
         if (! value) {
-            console.log(sqlFilename + " skip");
+            log.info("db", sqlFilename + " skip");
             return;
         }
 
         // Check if patched
         if (! databasePatchedFiles[sqlFilename]) {
-            console.log(sqlFilename + " is not patched");
+            log.info("db", sqlFilename + " is not patched");
 
             if (value.parents) {
-                console.log(sqlFilename + " need parents");
+                log.info("db", sqlFilename + " need parents");
                 for (let parentSQLFilename of value.parents) {
                     await this.patch2Recursion(parentSQLFilename, databasePatchedFiles);
                 }
@@ -238,24 +367,24 @@ class Database {
 
             this.backup(dayjs().format("YYYYMMDDHHmmss"));
 
-            console.log(sqlFilename + " is patching");
+            log.info("db", sqlFilename + " is patching");
             this.patched = true;
             await this.importSQLFile("./db/" + sqlFilename);
             databasePatchedFiles[sqlFilename] = true;
-            console.log(sqlFilename + " was patched successfully");
+            log.info("db", sqlFilename + " was patched successfully");
 
         } else {
-            debug(sqlFilename + " is already patched, skip");
+            log.debug("db", sqlFilename + " is already patched, skip");
         }
     }
 
     /**
-     * Sadly, multi sql statements is not supported by many sqlite libraries, I have to implement it myself
-     * @param filename
+     * Load an SQL file and execute it
+     * @param filename Filename of SQL file to import
      * @returns {Promise<void>}
      */
     static async importSQLFile(filename) {
-
+        // Sadly, multi sql statements is not supported by many sqlite libraries, I have to implement it myself
         await R.getCell("SELECT 1");
 
         let text = fs.readFileSync(filename).toString();
@@ -283,6 +412,10 @@ class Database {
         }
     }
 
+    /**
+     * Aquire a direct connection to database
+     * @returns {any}
+     */
     static getBetterSQLite3Database() {
         return R.knex.client.acquireConnection();
     }
@@ -297,7 +430,7 @@ class Database {
         };
         process.addListener("unhandledRejection", listener);
 
-        console.log("Closing the database");
+        log.info("db", "Closing the database");
 
         while (true) {
             Database.noReject = true;
@@ -307,10 +440,10 @@ class Database {
             if (Database.noReject) {
                 break;
             } else {
-                console.log("Waiting to close the database");
+                log.info("db", "Waiting to close the database");
             }
         }
-        console.log("SQLite closed");
+        log.info("db", "SQLite closed");
 
         process.removeListener("unhandledRejection", listener);
     }
@@ -318,11 +451,11 @@ class Database {
     /**
      * One backup one time in this process.
      * Reset this.backupPath if you want to backup again
-     * @param version
+     * @param {string} version Version code of backup
      */
     static backup(version) {
         if (! this.backupPath) {
-            console.info("Backing up the database");
+            log.info("db", "Backing up the database");
             this.backupPath = this.dataDir + "kuma.db.bak" + version;
             fs.copyFileSync(Database.path, this.backupPath);
 
@@ -337,19 +470,44 @@ class Database {
                 this.backupWalPath = walPath + ".bak" + version;
                 fs.copyFileSync(walPath, this.backupWalPath);
             }
+
+            // Double confirm if all files actually backup
+            if (!fs.existsSync(this.backupPath)) {
+                throw new Error("Backup failed! " + this.backupPath);
+            }
+
+            if (fs.existsSync(shmPath)) {
+                if (!fs.existsSync(this.backupShmPath)) {
+                    throw new Error("Backup failed! " + this.backupShmPath);
+                }
+            }
+
+            if (fs.existsSync(walPath)) {
+                if (!fs.existsSync(this.backupWalPath)) {
+                    throw new Error("Backup failed! " + this.backupWalPath);
+                }
+            }
         }
     }
 
-    /**
-     *
-     */
+    /** Restore from most recent backup */
     static restore() {
         if (this.backupPath) {
-            console.error("Patching the database failed!!! Restoring the backup");
+            log.error("db", "Patching the database failed!!! Restoring the backup");
 
             const shmPath = Database.path + "-shm";
             const walPath = Database.path + "-wal";
 
+            // Make sure we have a backup to restore before deleting old db
+            if (
+                !fs.existsSync(this.backupPath)
+                && !fs.existsSync(shmPath)
+                && !fs.existsSync(walPath)
+            ) {
+                log.error("db", "Backup file not found! Leaving database in failed state.");
+                process.exit(1);
+            }
+
             // Delete patch failed db
             try {
                 if (fs.existsSync(Database.path)) {
@@ -364,7 +522,7 @@ class Database {
                     fs.unlinkSync(walPath);
                 }
             } catch (e) {
-                console.log("Restore failed; you may need to restore the backup manually");
+                log.error("db", "Restore failed; you may need to restore the backup manually");
                 process.exit(1);
             }
 
@@ -380,17 +538,22 @@ class Database {
             }
 
         } else {
-            console.log("Nothing to restore");
+            log.info("db", "Nothing to restore");
         }
     }
 
+    /** Get the size of the database */
     static getSize() {
-        debug("Database.getSize()");
+        log.debug("db", "Database.getSize()");
         let stats = fs.statSync(Database.path);
-        debug(stats);
+        log.debug("db", stats);
         return stats.size;
     }
 
+    /**
+     * Shrink the database
+     * @returns {Promise<void>}
+     */
     static async shrink() {
         await R.exec("VACUUM");
     }

server/docker.js

@@ -0,0 +1,118 @@
+const axios = require("axios");
+const { R } = require("redbean-node");
+const version = require("../package.json").version;
+const https = require("https");
+
+class DockerHost {
+    /**
+     * Save a docker host
+     * @param {Object} dockerHost Docker host to save
+     * @param {?number} dockerHostID ID of the docker host to update
+     * @param {number} userID ID of the user who adds the docker host
+     * @returns {Promise<Bean>}
+     */
+    static async save(dockerHost, dockerHostID, userID) {
+        let bean;
+
+        if (dockerHostID) {
+            bean = await R.findOne("docker_host", " id = ? AND user_id = ? ", [ dockerHostID, userID ]);
+
+            if (!bean) {
+                throw new Error("docker host not found");
+            }
+
+        } else {
+            bean = R.dispense("docker_host");
+        }
+
+        bean.user_id = userID;
+        bean.docker_daemon = dockerHost.dockerDaemon;
+        bean.docker_type = dockerHost.dockerType;
+        bean.name = dockerHost.name;
+
+        await R.store(bean);
+
+        return bean;
+    }
+
+    /**
+     * Delete a Docker host
+     * @param {number} dockerHostID ID of the Docker host to delete
+     * @param {number} userID ID of the user who created the Docker host
+     * @returns {Promise<void>}
+     */
+    static async delete(dockerHostID, userID) {
+        let bean = await R.findOne("docker_host", " id = ? AND user_id = ? ", [ dockerHostID, userID ]);
+
+        if (!bean) {
+            throw new Error("docker host not found");
+        }
+
+        // Delete removed proxy from monitors if exists
+        await R.exec("UPDATE monitor SET docker_host = null WHERE docker_host = ?", [ dockerHostID ]);
+
+        await R.trash(bean);
+    }
+
+    /**
+     * Fetches the amount of containers on the Docker host
+     * @param {Object} dockerHost Docker host to check for
+     * @returns {number} Total amount of containers on the host
+     */
+    static async testDockerHost(dockerHost) {
+        const options = {
+            url: "/containers/json?all=true",
+            headers: {
+                "Accept": "*/*",
+                "User-Agent": "Uptime-Kuma/" + version
+            },
+            httpsAgent: new https.Agent({
+                maxCachedSessions: 0,      // Use Custom agent to disable session reuse (https://github.com/nodejs/node/issues/3940)
+                rejectUnauthorized: false,
+            }),
+        };
+
+        if (dockerHost.dockerType === "socket") {
+            options.socketPath = dockerHost.dockerDaemon;
+        } else if (dockerHost.dockerType === "tcp") {
+            options.baseURL = DockerHost.patchDockerURL(dockerHost.dockerDaemon);
+        }
+
+        let res = await axios.request(options);
+
+        if (Array.isArray(res.data)) {
+
+            if (res.data.length > 1) {
+
+                if ("ImageID" in res.data[0]) {
+                    return res.data.length;
+                } else {
+                    throw new Error("Invalid Docker response, is it Docker really a daemon?");
+                }
+
+            } else {
+                return res.data.length;
+            }
+
+        } else {
+            throw new Error("Invalid Docker response, is it Docker really a daemon?");
+        }
+
+    }
+
+    /**
+     * Since axios 0.27.X, it does not accept `tcp://` protocol.
+     * Change it to `http://` on the fly in order to fix it. (https://github.com/louislam/uptime-kuma/issues/2165)
+     */
+    static patchDockerURL(url) {
+        if (typeof url === "string") {
+            // Replace the first occurrence only with g
+            return url.replace(/tcp:\/\//g, "http://");
+        }
+        return url;
+    }
+}
+
+module.exports = {
+    DockerHost,
+};

server/git.js

@@ -0,0 +1,24 @@
+const childProcess = require("child_process");
+
+class Git {
+
+    static clone(repoURL, cwd, targetDir = ".") {
+        let result = childProcess.spawnSync("git", [
+            "clone",
+            repoURL,
+            targetDir,
+        ], {
+            cwd: cwd,
+        });
+
+        if (result.status !== 0) {
+            throw new Error(result.stderr.toString("utf-8"));
+        } else {
+            return result.stdout.toString("utf-8") + result.stderr.toString("utf-8");
+        }
+    }
+}
+
+module.exports = {
+    Git,
+};

server/google-analytics.js

@@ -0,0 +1,24 @@
+const jsesc = require("jsesc");
+
+/**
+ * Returns a string that represents the javascript that is required to insert the Google Analytics scripts
+ * into a webpage.
+ * @param tagId Google UA/G/AW/DC Property ID to use with the Google Analytics script.
+ * @returns {string}
+ */
+function getGoogleAnalyticsScript(tagId) {
+    let escapedTagId = jsesc(tagId, { isScriptContext: true });
+
+    if (escapedTagId) {
+        escapedTagId = escapedTagId.trim();
+    }
+
+    return `
+        <script async src="https://www.googletagmanager.com/gtag/js?id=${escapedTagId}"></script>
+        <script>window.dataLayer = window.dataLayer || []; function gtag(){dataLayer.push(arguments);} gtag('js', new Date());gtag('config', '${escapedTagId}'); </script>
+    `;
+}
+
+module.exports = {
+    getGoogleAnalyticsScript,
+};

server/image-data-uri.js

@@ -3,12 +3,21 @@
     Modified with 0 dependencies
  */
 let fs = require("fs");
+const { log } = require("../src/util");
 
 let ImageDataURI = (() => {
 
+    /**
+     * Decode the data:image/ URI
+     * @param {string} dataURI data:image/ URI to decode
+     * @returns {?Object} An object with properties "imageType" and "dataBase64".
+     * The former is the image type, e.g., "png", and the latter is a base64
+     * encoded string of the image's binary data. If it fails to parse, returns
+     * null instead of an object.
+     */
     function decode(dataURI) {
         if (!/data:image\//.test(dataURI)) {
-            console.log("ImageDataURI :: Error :: It seems that it is not an Image Data URI. Couldn't match \"data:image/\"");
+            log.error("image-data-uri", "It seems that it is not an Image Data URI. Couldn't match \"data:image/\"");
             return null;
         }
 
@@ -20,9 +29,16 @@ let ImageDataURI = (() => {
         };
     }
 
+    /**
+     * Endcode an image into data:image/ URI
+     * @param {(Buffer|string)} data Data to encode
+     * @param {string} mediaType Media type of data
+     * @returns {(string|null)} A string representing the base64-encoded
+     * version of the given Buffer object or null if an error occurred.
+     */
     function encode(data, mediaType) {
         if (!data || !mediaType) {
-            console.log("ImageDataURI :: Error :: Missing some of the required params: data, mediaType ");
+            log.error("image-data-uri", "Missing some of the required params: data, mediaType");
             return null;
         }
 
@@ -33,6 +49,12 @@ let ImageDataURI = (() => {
         return dataImgBase64;
     }
 
+    /**
+     * Write data URI to file
+     * @param {string} dataURI data:image/ URI
+     * @param {string} [filePath] Path to write file to
+     * @returns {Promise<string>}
+     */
     function outputFile(dataURI, filePath) {
         filePath = filePath || "./";
         return new Promise((resolve, reject) => {

server/jobs.js

@@ -1,7 +1,8 @@
 const path = require("path");
 const Bree = require("bree");
 const { SHARE_ENV } = require("worker_threads");
-
+const { log } = require("../src/util");
+let bree;
 const jobs = [
     {
         name: "clear-old-data",
@@ -9,8 +10,13 @@ const jobs = [
     },
 ];
 
+/**
+ * Initialize background jobs
+ * @param {Object} args Arguments to pass to workers
+ * @returns {Bree}
+ */
 const initBackgroundJobs = function (args) {
-    const bree = new Bree({
+    bree = new Bree({
         root: path.resolve("server", "jobs"),
         jobs,
         worker: {
@@ -18,7 +24,7 @@ const initBackgroundJobs = function (args) {
             workerData: args,
         },
         workerMessageHandler: (message) => {
-            console.log("[Background Job]:", message);
+            log.info("jobs", message);
         }
     });
 
@@ -26,6 +32,14 @@ const initBackgroundJobs = function (args) {
     return bree;
 };
 
-module.exports = {
-    initBackgroundJobs
+/** Stop all background jobs if running */
+const stopBackgroundJobs = function () {
+    if (bree) {
+        bree.stop();
+    }
+};
+
+module.exports = {
+    initBackgroundJobs,
+    stopBackgroundJobs
 };

server/jobs/clear-old-data.js

@@ -25,15 +25,20 @@ const DEFAULT_KEEP_PERIOD = 180;
         parsedPeriod = DEFAULT_KEEP_PERIOD;
     }
 
-    log(`Clearing Data older than ${parsedPeriod} days...`);
+    if (parsedPeriod < 1) {
+        log(`Data deletion has been disabled as period is less than 1. Period is ${parsedPeriod} days.`);
+    } else {
 
-    try {
-        await R.exec(
-            "DELETE FROM heartbeat WHERE time < DATETIME('now', '-' || ? || ' days') ",
-            [parsedPeriod]
-        );
-    } catch (e) {
-        log(`Failed to clear old data: ${e.message}`);
+        log(`Clearing Data older than ${parsedPeriod} days...`);
+
+        try {
+            await R.exec(
+                "DELETE FROM heartbeat WHERE time < DATETIME('now', '-' || ? || ' days') ",
+                [ parsedPeriod ]
+            );
+        } catch (e) {
+            log(`Failed to clear old data: ${e.message}`);
+        }
     }
 
     exit();

server/jobs/util-worker.js

@@ -2,14 +2,24 @@ const { parentPort, workerData } = require("worker_threads");
 const Database = require("../database");
 const path = require("path");
 
+/**
+ * Send message to parent process for logging
+ * since worker_thread does not have access to stdout, this is used
+ * instead of console.log()
+ * @param {any} any The message to log
+ */
 const log = function (any) {
     if (parentPort) {
         parentPort.postMessage(any);
     }
 };
 
+/**
+ * Exit the worker process
+ * @param {number} error The status code to exit
+ */
 const exit = function (error) {
-    if (error && error != 0) {
+    if (error && error !== 0) {
         process.exit(error);
     } else {
         if (parentPort) {
@@ -20,6 +30,7 @@ const exit = function (error) {
     }
 };
 
+/** Connects to the database */
 const connectDb = async function () {
     const dbPath = path.join(
         process.env.DATA_DIR || workerData["data-dir"] || "./data/"

server/model/docker_host.js

@@ -0,0 +1,19 @@
+const { BeanModel } = require("redbean-node/dist/bean-model");
+
+class DockerHost extends BeanModel {
+    /**
+     * Returns an object that ready to parse to JSON
+     * @returns {Object}
+     */
+    toJSON() {
+        return {
+            id: this.id,
+            userID: this.user_id,
+            dockerDaemon: this.docker_daemon,
+            dockerType: this.docker_type,
+            name: this.name,
+        };
+    }
+}
+
+module.exports = DockerHost;

server/model/group.js

@@ -3,12 +3,18 @@ const { R } = require("redbean-node");
 
 class Group extends BeanModel {
 
-    async toPublicJSON() {
+    /**
+     * Return an object that ready to parse to JSON for public
+     * Only show necessary data to public
+     * @param {boolean} [showTags=false] Should the JSON include monitor tags
+     * @returns {Object}
+     */
+    async toPublicJSON(showTags = false) {
         let monitorBeanList = await this.getMonitorList();
         let monitorList = [];
 
         for (let bean of monitorBeanList) {
-            monitorList.push(await bean.toPublicJSON());
+            monitorList.push(await bean.toPublicJSON(showTags));
         }
 
         return {
@@ -19,9 +25,13 @@ class Group extends BeanModel {
         };
     }
 
+    /**
+     * Get all monitors
+     * @returns {Bean[]}
+     */
     async getMonitorList() {
         return R.convertToBeans("monitor", await R.getAll(`
-            SELECT monitor.* FROM monitor, monitor_group
+            SELECT monitor.*, monitor_group.send_url FROM monitor, monitor_group
             WHERE monitor.id = monitor_group.monitor_id
             AND group_id = ?
             ORDER BY monitor_group.weight

server/model/heartbeat.js

@@ -1,8 +1,3 @@
-const dayjs = require("dayjs");
-const utc = require("dayjs/plugin/utc");
-let timezone = require("dayjs/plugin/timezone");
-dayjs.extend(utc);
-dayjs.extend(timezone);
 const { BeanModel } = require("redbean-node/dist/bean-model");
 
 /**
@@ -10,9 +5,15 @@ const { BeanModel } = require("redbean-node/dist/bean-model");
  *      0 = DOWN
  *      1 = UP
  *      2 = PENDING
+ *      3 = MAINTENANCE
  */
 class Heartbeat extends BeanModel {
 
+    /**
+     * Return an object that ready to parse to JSON for public
+     * Only show necessary data to public
+     * @returns {Object}
+     */
     toPublicJSON() {
         return {
             status: this.status,
@@ -22,6 +23,10 @@ class Heartbeat extends BeanModel {
         };
     }
 
+    /**
+     * Return an object that ready to parse to JSON
+     * @returns {Object}
+     */
     toJSON() {
         return {
             monitorID: this.monitor_id,

server/model/incident.js

@@ -2,6 +2,11 @@ const { BeanModel } = require("redbean-node/dist/bean-model");
 
 class Incident extends BeanModel {
 
+    /**
+     * Return an object that ready to parse to JSON for public
+     * Only show necessary data to public
+     * @returns {Object}
+     */
     toPublicJSON() {
         return {
             id: this.id,

server/model/maintenance.js

@@ -0,0 +1,240 @@
+const { BeanModel } = require("redbean-node/dist/bean-model");
+const { parseTimeObject, parseTimeFromTimeObject, utcToLocal, localToUTC, log } = require("../../src/util");
+const { timeObjectToUTC, timeObjectToLocal } = require("../util-server");
+const { R } = require("redbean-node");
+const dayjs = require("dayjs");
+
+class Maintenance extends BeanModel {
+
+    /**
+     * Return an object that ready to parse to JSON for public
+     * Only show necessary data to public
+     * @returns {Object}
+     */
+    async toPublicJSON() {
+
+        let dateRange = [];
+        if (this.start_date) {
+            dateRange.push(utcToLocal(this.start_date));
+            if (this.end_date) {
+                dateRange.push(utcToLocal(this.end_date));
+            }
+        }
+
+        let timeRange = [];
+        let startTime = timeObjectToLocal(parseTimeObject(this.start_time));
+        timeRange.push(startTime);
+        let endTime = timeObjectToLocal(parseTimeObject(this.end_time));
+        timeRange.push(endTime);
+
+        let obj = {
+            id: this.id,
+            title: this.title,
+            description: this.description,
+            strategy: this.strategy,
+            intervalDay: this.interval_day,
+            active: !!this.active,
+            dateRange: dateRange,
+            timeRange: timeRange,
+            weekdays: (this.weekdays) ? JSON.parse(this.weekdays) : [],
+            daysOfMonth: (this.days_of_month) ? JSON.parse(this.days_of_month) : [],
+            timeslotList: [],
+        };
+
+        const timeslotList = await this.getTimeslotList();
+
+        for (let timeslot of timeslotList) {
+            obj.timeslotList.push(await timeslot.toPublicJSON());
+        }
+
+        if (!Array.isArray(obj.weekdays)) {
+            obj.weekdays = [];
+        }
+
+        if (!Array.isArray(obj.daysOfMonth)) {
+            obj.daysOfMonth = [];
+        }
+
+        // Maintenance Status
+        if (!obj.active) {
+            obj.status = "inactive";
+        } else if (obj.strategy === "manual") {
+            obj.status = "under-maintenance";
+        } else if (obj.timeslotList.length > 0) {
+            let currentTimestamp = dayjs().unix();
+
+            for (let timeslot of obj.timeslotList) {
+                if (dayjs.utc(timeslot.startDate).unix() <= currentTimestamp && dayjs.utc(timeslot.endDate).unix() >= currentTimestamp) {
+                    log.debug("timeslot", "Timeslot ID: " + timeslot.id);
+                    log.debug("timeslot", "currentTimestamp:" + currentTimestamp);
+                    log.debug("timeslot", "timeslot.start_date:" + dayjs.utc(timeslot.startDate).unix());
+                    log.debug("timeslot", "timeslot.end_date:" + dayjs.utc(timeslot.endDate).unix());
+
+                    obj.status = "under-maintenance";
+                    break;
+                }
+            }
+
+            if (!obj.status) {
+                obj.status = "scheduled";
+            }
+        } else if (obj.timeslotList.length === 0) {
+            obj.status = "ended";
+        } else {
+            obj.status = "unknown";
+        }
+
+        return obj;
+    }
+
+    /**
+     * Only get future or current timeslots only
+     * @returns {Promise<[]>}
+     */
+    async getTimeslotList() {
+        return R.convertToBeans("maintenance_timeslot", await R.getAll(`
+            SELECT maintenance_timeslot.*
+            FROM maintenance_timeslot, maintenance
+            WHERE maintenance_timeslot.maintenance_id = maintenance.id
+            AND maintenance.id = ?
+            AND ${Maintenance.getActiveAndFutureMaintenanceSQLCondition()}
+        `, [
+            this.id
+        ]));
+    }
+
+    /**
+     * Return an object that ready to parse to JSON
+     * @param {string} timezone If not specified, the timeRange will be in UTC
+     * @returns {Object}
+     */
+    async toJSON(timezone = null) {
+        return this.toPublicJSON(timezone);
+    }
+
+    /**
+     * Get a list of weekdays that the maintenance is active for
+     * Monday=1, Tuesday=2 etc.
+     * @returns {number[]} Array of active weekdays
+     */
+    getDayOfWeekList() {
+        log.debug("timeslot", "List: " + this.weekdays);
+        return JSON.parse(this.weekdays).sort(function (a, b) {
+            return a - b;
+        });
+    }
+
+    /**
+     * Get a list of days in month that maintenance is active for
+     * @returns {number[]} Array of active days in month
+     */
+    getDayOfMonthList() {
+        return JSON.parse(this.days_of_month).sort(function (a, b) {
+            return a - b;
+        });
+    }
+
+    /**
+     * Get the start date and time for maintenance
+     * @returns {dayjs.Dayjs} Start date and time
+     */
+    getStartDateTime() {
+        let startOfTheDay = dayjs.utc(this.start_date).format("HH:mm");
+        log.debug("timeslot", "startOfTheDay: " + startOfTheDay);
+
+        // Start Time
+        let startTimeSecond = dayjs.utc(this.start_time, "HH:mm").diff(dayjs.utc(startOfTheDay, "HH:mm"), "second");
+        log.debug("timeslot", "startTime: " + startTimeSecond);
+
+        // Bake StartDate + StartTime = Start DateTime
+        return dayjs.utc(this.start_date).add(startTimeSecond, "second");
+    }
+
+    /**
+     * Get the duraction of maintenance in seconds
+     * @returns {number} Duration of maintenance
+     */
+    getDuration() {
+        let duration = dayjs.utc(this.end_time, "HH:mm").diff(dayjs.utc(this.start_time, "HH:mm"), "second");
+        // Add 24hours if it is across day
+        if (duration < 0) {
+            duration += 24 * 3600;
+        }
+        return duration;
+    }
+
+    /**
+     * Convert data from socket to bean
+     * @param {Bean} bean Bean to fill in
+     * @param {Object} obj Data to fill bean with
+     * @returns {Bean} Filled bean
+     */
+    static jsonToBean(bean, obj) {
+        if (obj.id) {
+            bean.id = obj.id;
+        }
+
+        // Apply timezone offset to timeRange, as it cannot apply automatically.
+        if (obj.timeRange[0]) {
+            timeObjectToUTC(obj.timeRange[0]);
+            if (obj.timeRange[1]) {
+                timeObjectToUTC(obj.timeRange[1]);
+            }
+        }
+
+        bean.title = obj.title;
+        bean.description = obj.description;
+        bean.strategy = obj.strategy;
+        bean.interval_day = obj.intervalDay;
+        bean.active = obj.active;
+
+        if (obj.dateRange[0]) {
+            bean.start_date = localToUTC(obj.dateRange[0]);
+
+            if (obj.dateRange[1]) {
+                bean.end_date = localToUTC(obj.dateRange[1]);
+            }
+        }
+
+        bean.start_time = parseTimeFromTimeObject(obj.timeRange[0]);
+        bean.end_time = parseTimeFromTimeObject(obj.timeRange[1]);
+
+        bean.weekdays = JSON.stringify(obj.weekdays);
+        bean.days_of_month = JSON.stringify(obj.daysOfMonth);
+
+        return bean;
+    }
+
+    /**
+     * SQL conditions for active maintenance
+     * @returns {string}
+     */
+    static getActiveMaintenanceSQLCondition() {
+        return `
+            (
+                (maintenance_timeslot.start_date <= DATETIME('now')
+                AND maintenance_timeslot.end_date >= DATETIME('now')
+                AND maintenance.active = 1)
+                OR
+                (maintenance.strategy = 'manual' AND active = 1)
+            )
+        `;
+    }
+
+    /**
+     * SQL conditions for active and future maintenance
+     * @returns {string}
+     */
+    static getActiveAndFutureMaintenanceSQLCondition() {
+        return `
+            (
+                ((maintenance_timeslot.end_date >= DATETIME('now')
+                AND maintenance.active = 1)
+                OR
+                (maintenance.strategy = 'manual' AND active = 1))
+            )
+        `;
+    }
+}
+
+module.exports = Maintenance;

server/model/maintenance_timeslot.js

@@ -0,0 +1,198 @@
+const { BeanModel } = require("redbean-node/dist/bean-model");
+const { R } = require("redbean-node");
+const dayjs = require("dayjs");
+const { log, utcToLocal, SQL_DATETIME_FORMAT_WITHOUT_SECOND, localToUTC } = require("../../src/util");
+const { UptimeKumaServer } = require("../uptime-kuma-server");
+
+class MaintenanceTimeslot extends BeanModel {
+
+    /**
+     * Return an object that ready to parse to JSON for public
+     * Only show necessary data to public
+     * @returns {Object}
+     */
+    async toPublicJSON() {
+        const serverTimezoneOffset = UptimeKumaServer.getInstance().getTimezoneOffset();
+
+        const obj = {
+            id: this.id,
+            startDate: this.start_date,
+            endDate: this.end_date,
+            startDateServerTimezone: utcToLocal(this.start_date, SQL_DATETIME_FORMAT_WITHOUT_SECOND),
+            endDateServerTimezone: utcToLocal(this.end_date, SQL_DATETIME_FORMAT_WITHOUT_SECOND),
+            serverTimezoneOffset,
+        };
+
+        return obj;
+    }
+
+    /**
+     * Return an object that ready to parse to JSON
+     * @returns {Object}
+     */
+    async toJSON() {
+        return await this.toPublicJSON();
+    }
+
+    /**
+     * @param {Maintenance} maintenance
+     * @param {dayjs} minDate (For recurring type only) Generate a next timeslot from this date.
+     * @param {boolean} removeExist Remove existing timeslot before create
+     * @returns {Promise<MaintenanceTimeslot>}
+     */
+    static async generateTimeslot(maintenance, minDate = null, removeExist = false) {
+        if (removeExist) {
+            await R.exec("DELETE FROM maintenance_timeslot WHERE maintenance_id = ? ", [
+                maintenance.id
+            ]);
+        }
+
+        if (maintenance.strategy === "manual") {
+            log.debug("maintenance", "No need to generate timeslot for manual type");
+
+        } else if (maintenance.strategy === "single") {
+            let bean = R.dispense("maintenance_timeslot");
+            bean.maintenance_id = maintenance.id;
+            bean.start_date = maintenance.start_date;
+            bean.end_date = maintenance.end_date;
+            bean.generated_next = true;
+            return await R.store(bean);
+
+        } else if (maintenance.strategy === "recurring-interval") {
+            // Prevent dead loop, in case interval_day is not set
+            if (!maintenance.interval_day || maintenance.interval_day <= 0) {
+                maintenance.interval_day = 1;
+            }
+
+            return await this.handleRecurringType(maintenance, minDate, (startDateTime) => {
+                return startDateTime.add(maintenance.interval_day, "day");
+            }, () => {
+                return true;
+            });
+
+        } else if (maintenance.strategy === "recurring-weekday") {
+            let dayOfWeekList = maintenance.getDayOfWeekList();
+            log.debug("timeslot", dayOfWeekList);
+
+            if (dayOfWeekList.length <= 0) {
+                log.debug("timeslot", "No weekdays selected?");
+                return null;
+            }
+
+            const isValid = (startDateTime) => {
+                log.debug("timeslot", "nextDateTime: " + startDateTime);
+
+                let day = startDateTime.local().day();
+                log.debug("timeslot", "nextDateTime.day(): " + day);
+
+                return dayOfWeekList.includes(day);
+            };
+
+            return await this.handleRecurringType(maintenance, minDate, (startDateTime) => {
+                while (true) {
+                    startDateTime = startDateTime.add(1, "day");
+
+                    if (isValid(startDateTime)) {
+                        return startDateTime;
+                    }
+                }
+            }, isValid);
+
+        } else if (maintenance.strategy === "recurring-day-of-month") {
+            let dayOfMonthList = maintenance.getDayOfMonthList();
+            if (dayOfMonthList.length <= 0) {
+                log.debug("timeslot", "No day selected?");
+                return null;
+            }
+
+            const isValid = (startDateTime) => {
+                let day = parseInt(startDateTime.local().format("D"));
+
+                log.debug("timeslot", "day: " + day);
+
+                // Check 1-31
+                if (dayOfMonthList.includes(day)) {
+                    return startDateTime;
+                }
+
+                // Check "lastDay1","lastDay2"...
+                let daysInMonth = startDateTime.daysInMonth();
+                let lastDayList = [];
+
+                // Small first, e.g. 28 > 29 > 30 > 31
+                for (let i = 4; i >= 1; i--) {
+                    if (dayOfMonthList.includes("lastDay" + i)) {
+                        lastDayList.push(daysInMonth - i + 1);
+                    }
+                }
+                log.debug("timeslot", lastDayList);
+                return lastDayList.includes(day);
+            };
+
+            return await this.handleRecurringType(maintenance, minDate, (startDateTime) => {
+                while (true) {
+                    startDateTime = startDateTime.add(1, "day");
+                    if (isValid(startDateTime)) {
+                        return startDateTime;
+                    }
+                }
+            }, isValid);
+        } else {
+            throw new Error("Unknown maintenance strategy");
+        }
+    }
+
+    /**
+     * Generate a next timeslot for all recurring types
+     * @param maintenance
+     * @param minDate
+     * @param {function} nextDayCallback The logic how to get the next possible day
+     * @param {function} isValidCallback Check the day whether is matched the current strategy
+     * @returns {Promise<null|MaintenanceTimeslot>}
+     */
+    static async handleRecurringType(maintenance, minDate, nextDayCallback, isValidCallback) {
+        let bean = R.dispense("maintenance_timeslot");
+
+        let duration = maintenance.getDuration();
+        let startDateTime = maintenance.getStartDateTime();
+        let endDateTime;
+
+        // Keep generating from the first possible date, until it is ok
+        while (true) {
+            log.debug("timeslot", "startDateTime: " + startDateTime.format());
+
+            // Handling out of effective date range
+            if (startDateTime.diff(dayjs.utc(maintenance.end_date)) > 0) {
+                log.debug("timeslot", "Out of effective date range");
+                return null;
+            }
+
+            endDateTime = startDateTime.add(duration, "second");
+
+            // If endDateTime is out of effective date range, use the end datetime from effective date range
+            if (endDateTime.diff(dayjs.utc(maintenance.end_date)) > 0) {
+                endDateTime = dayjs.utc(maintenance.end_date);
+            }
+
+            // If minDate is set, the endDateTime must be bigger than it.
+            // And the endDateTime must be bigger current time
+            // Is valid under current recurring strategy
+            if (
+                (!minDate || endDateTime.diff(minDate) > 0) &&
+                endDateTime.diff(dayjs()) > 0 &&
+                isValidCallback(startDateTime)
+            ) {
+                break;
+            }
+            startDateTime = nextDayCallback(startDateTime);
+        }
+
+        bean.maintenance_id = maintenance.id;
+        bean.start_date = localToUTC(startDateTime);
+        bean.end_date = localToUTC(endDateTime);
+        bean.generated_next = false;
+        return await R.store(bean);
+    }
+}
+
+module.exports = MaintenanceTimeslot;

server/model/proxy.js

@@ -0,0 +1,25 @@
+const { BeanModel } = require("redbean-node/dist/bean-model");
+
+class Proxy extends BeanModel {
+    /**
+     * Return an object that ready to parse to JSON
+     * @returns {Object}
+     */
+    toJSON() {
+        return {
+            id: this._id,
+            userId: this._user_id,
+            protocol: this._protocol,
+            host: this._host,
+            port: this._port,
+            auth: !!this._auth,
+            username: this._username,
+            password: this._password,
+            active: !!this._active,
+            default: !!this._default,
+            createdDate: this._created_date,
+        };
+    }
+}
+
+module.exports = Proxy;

server/model/status_page.js

@@ -0,0 +1,318 @@
+const { BeanModel } = require("redbean-node/dist/bean-model");
+const { R } = require("redbean-node");
+const cheerio = require("cheerio");
+const { UptimeKumaServer } = require("../uptime-kuma-server");
+const jsesc = require("jsesc");
+const Maintenance = require("./maintenance");
+const googleAnalytics = require("../google-analytics");
+
+class StatusPage extends BeanModel {
+
+    /**
+     * Like this: { "test-uptime.kuma.pet": "default" }
+     * @type {{}}
+     */
+    static domainMappingList = { };
+
+    /**
+     *
+     * @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) {
+            response.send(await StatusPage.renderHTML(indexHTML, statusPage));
+        } else {
+            response.status(404).send(UptimeKumaServer.getInstance().indexHTML);
+        }
+    }
+
+    /**
+     * SSR for status pages
+     * @param {string} indexHTML
+     * @param {StatusPage} statusPage
+     */
+    static async renderHTML(indexHTML, statusPage) {
+        const $ = cheerio.load(indexHTML);
+        const description155 = statusPage.description?.substring(0, 155) ?? "";
+
+        $("title").text(statusPage.title);
+        $("meta[name=description]").attr("content", description155);
+
+        if (statusPage.icon) {
+            $("link[rel=icon]")
+                .attr("href", statusPage.icon)
+                .removeAttr("type");
+
+            $("link[rel=apple-touch-icon]").remove();
+        }
+
+        const head = $("head");
+
+        if (statusPage.googleAnalyticsTagId) {
+            let escapedGoogleAnalyticsScript = googleAnalytics.getGoogleAnalyticsScript(statusPage.googleAnalyticsTagId);
+            head.append($(escapedGoogleAnalyticsScript));
+        }
+
+        // OG Meta Tags
+        let ogTitle = $("<meta property=\"og:title\" content=\"\" />").attr("content", statusPage.title);
+        head.append(ogTitle);
+
+        let ogDescription = $("<meta property=\"og:description\" content=\"\" />").attr("content", description155);
+        head.append(ogDescription);
+
+        // Preload data
+        // Add jsesc, fix https://github.com/louislam/uptime-kuma/issues/2186
+        const escapedJSONObject = jsesc(await StatusPage.getStatusPageData(statusPage), {
+            "isScriptContext": true
+        });
+
+        const script = $(`
+            <script id="preload-data" data-json="{}">
+                window.preloadData = ${escapedJSONObject};
+            </script>
+        `);
+
+        head.append(script);
+
+        // manifest.json
+        $("link[rel=manifest]").attr("href", `/api/status-page/${statusPage.slug}/manifest.json`);
+
+        return $.root().html();
+    }
+
+    /**
+     * 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);
+
+        // 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,
+        };
+    }
+
+    /**
+     * Loads domain mapping from DB
+     * Return object like this: { "test-uptime.kuma.pet": "default" }
+     * @returns {Promise<void>}
+     */
+    static async loadDomainMappingList() {
+        StatusPage.domainMappingList = await R.getAssoc(`
+            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[]>}
+     */
+    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>}
+     */
+    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[]}
+     */
+    getDomainNameList() {
+        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}
+     */
+    async toJSON() {
+        return {
+            id: this.id,
+            slug: this.slug,
+            title: this.title,
+            description: this.description,
+            icon: this.getIcon(),
+            theme: this.theme,
+            published: !!this.published,
+            showTags: !!this.show_tags,
+            domainNameList: this.getDomainNameList(),
+            customCSS: this.custom_css,
+            footerText: this.footer_text,
+            showPoweredBy: !!this.show_powered_by,
+            googleAnalyticsId: this.google_analytics_tag_id,
+        };
+    }
+
+    /**
+     * Return an object that ready to parse to JSON for public
+     * Only show necessary data to public
+     * @returns {Object}
+     */
+    async toPublicJSON() {
+        return {
+            slug: this.slug,
+            title: this.title,
+            description: this.description,
+            icon: this.getIcon(),
+            theme: this.theme,
+            published: !!this.published,
+            showTags: !!this.show_tags,
+            customCSS: this.custom_css,
+            footerText: this.footer_text,
+            showPoweredBy: !!this.show_powered_by,
+            googleAnalyticsId: this.google_analytics_tag_id,
+        };
+    }
+
+    /**
+     * 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 DISTINCT 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 [];
+        }
+    }
+}
+
+module.exports = StatusPage;

server/model/tag.js

@@ -1,6 +1,11 @@
 const { BeanModel } = require("redbean-node/dist/bean-model");
 
 class Tag extends BeanModel {
+
+    /**
+     * Return an object that ready to parse to JSON
+     * @returns {Object}
+     */
     toJSON() {
         return {
             id: this._id,

server/model/user.js

@@ -3,19 +3,30 @@ const passwordHash = require("../password-hash");
 const { R } = require("redbean-node");
 
 class User extends BeanModel {
+    /**
+     * Reset user password
+     * Fix #1510, as in the context reset-password.js, there is no auto model mapping. Call this static function instead.
+     * @param {number} userID ID of user to update
+     * @param {string} newPassword
+     * @returns {Promise<void>}
+     */
+    static async resetPassword(userID, newPassword) {
+        await R.exec("UPDATE `user` SET password = ? WHERE id = ? ", [
+            passwordHash.generate(newPassword),
+            userID
+        ]);
+    }
 
     /**
-     * Direct execute, no need R.store()
-     * @param newPassword
+     * Reset this users password
+     * @param {string} newPassword
      * @returns {Promise<void>}
      */
     async resetPassword(newPassword) {
-        await R.exec("UPDATE `user` SET password = ? WHERE id = ? ", [
-            passwordHash.generate(newPassword),
-            this.id
-        ]);
+        await User.resetPassword(this.id, newPassword);
         this.password = newPassword;
     }
+
 }
 
 module.exports = User;

server/modules/apicache/apicache.js

@@ -13,27 +13,49 @@ let t = {
 
 let instances = [];
 
+/**
+ * Does a === b
+ * @param {any} a
+ * @returns {function(any): boolean}
+ */
 let matches = function (a) {
     return function (b) {
         return a === b;
     };
 };
 
+/**
+ * Does a!==b
+ * @param {any} a
+ * @returns {function(any): boolean}
+ */
 let doesntMatch = function (a) {
     return function (b) {
         return !matches(a)(b);
     };
 };
 
+/**
+ * Get log duration
+ * @param {number} d Time in ms
+ * @param {string} prefix Prefix for log
+ * @returns {string} Coloured log string
+ */
 let logDuration = function (d, prefix) {
     let str = d > 1000 ? (d / 1000).toFixed(2) + "sec" : d + "ms";
     return "\x1b[33m- " + (prefix ? prefix + " " : "") + str + "\x1b[0m";
 };
 
+/**
+ * Get safe headers
+ * @param {Object} res Express response object
+ * @returns {Object}
+ */
 function getSafeHeaders(res) {
     return res.getHeaders ? res.getHeaders() : res._headers;
 }
 
+/** Constructor for ApiCache instance */
 function ApiCache() {
     let memCache = new MemoryCache();
 
@@ -68,6 +90,15 @@ function ApiCache() {
     instances.push(this);
     this.id = instances.length;
 
+    /**
+     * Logs a message to the console if the `DEBUG` environment variable is set.
+     * @param {string} a The first argument to log.
+     * @param {string} b The second argument to log.
+     * @param {string} c The third argument to log.
+     * @param {string} d The fourth argument to log, and so on... (optional)
+     *
+     * Generated by Trelent
+     */
     function debug(a, b, c, d) {
         let arr = ["\x1b[36m[apicache]\x1b[0m", a, b, c, d].filter(function (arg) {
             return arg !== undefined;
@@ -77,6 +108,13 @@ function ApiCache() {
         return (globalOptions.debug || debugEnv) && console.log.apply(null, arr);
     }
 
+    /**
+     * Returns true if the given request and response should be logged.
+     * @param {Object} request The HTTP request object.
+     * @param {Object} response The HTTP response object.
+     * @param {function(Object, Object):boolean} toggle
+     * @returns {boolean}
+     */
     function shouldCacheResponse(request, response, toggle) {
         let opt = globalOptions;
         let codes = opt.statusCodes;
@@ -99,6 +137,11 @@ function ApiCache() {
         return true;
     }
 
+    /**
+     * Add key to index array
+     * @param {string} key Key to add
+     * @param {Object} req Express request object
+     */
     function addIndexEntries(key, req) {
         let groupName = req.apicacheGroup;
 
@@ -111,6 +154,16 @@ function ApiCache() {
         index.all.unshift(key);
     }
 
+    /**
+     * Returns a new object containing only the whitelisted headers.
+     * @param {Object} headers The original object of header names and
+     * values.
+     * @param {string[]} globalOptions.headerWhitelist An array of
+     * strings representing the whitelisted header names to keep in the
+     * output object.
+     *
+     * Generated by Trelent
+     */
     function filterBlacklistedHeaders(headers) {
         return Object.keys(headers)
             .filter(function (key) {
@@ -122,6 +175,14 @@ function ApiCache() {
             }, {});
     }
 
+    /**
+     * Create a cache object
+     * @param {Object} headers The response headers to filter.
+     * @returns {Object} A new object containing only the whitelisted
+     * response headers.
+     *
+     * Generated by Trelent
+     */
     function createCacheObject(status, headers, data, encoding) {
         return {
             status: status,
@@ -132,6 +193,15 @@ function ApiCache() {
         };
     }
 
+    /**
+     * Sets a cache value for the given key.
+     * @param {string} key The cache key to set.
+     * @param {any} value The cache value to set.
+     * @param {number} duration How long in milliseconds the cached
+     * response should be valid for (defaults to 1 hour).
+     *
+     * Generated by Trelent
+     */
     function cacheResponse(key, value, duration) {
         let redis = globalOptions.redisClient;
         let expireCallback = globalOptions.events.expire;
@@ -154,6 +224,13 @@ function ApiCache() {
         }, Math.min(duration, 2147483647));
     }
 
+    /**
+     * Appends content to the response.
+     * @param {Object} res Express response object
+     * @param {(string|Buffer)} content The content to append.
+     *
+     * Generated by Trelent
+     */
     function accumulateContent(res, content) {
         if (content) {
             if (typeof content == "string") {
@@ -179,6 +256,17 @@ function ApiCache() {
         }
     }
 
+    /**
+     * Monkeypatches the response object to add cache control headers
+     * and create a cache object.
+     * @param {Object} req Express request object
+     * @param {Object} res Express response object
+     * @param {function} next Function to call next
+     * @param {string} key Key to add response as
+     * @param {number} duration Time to cache response for
+     * @param {string} strDuration Duration in string form
+     * @param {function(Object, Object):boolean} toggle
+     */
     function makeResponseCacheable(req, res, next, key, duration, strDuration, toggle) {
     // monkeypatch res.end to create cache object
         res._apicache = {
@@ -245,6 +333,17 @@ function ApiCache() {
         next();
     }
 
+    /**
+     * Send a cached response to client
+     * @param {Request} request Express request object
+     * @param {Response} response Express response object
+     * @param {object} cacheObject Cache object to send
+     * @param {function(Object, Object):boolean} toggle
+     * @param {function} next Function to call next
+     * @param {number} duration Not used
+     * @returns {boolean|undefined} true if the request should be
+     * cached, false otherwise. If undefined, defaults to true.
+     */
     function sendCachedResponse(request, response, cacheObject, toggle, next, duration) {
         if (toggle && !toggle(request, response)) {
             return next();
@@ -285,12 +384,19 @@ function ApiCache() {
         return response.end(data, cacheObject.encoding);
     }
 
+    /** Sync caching options */
     function syncOptions() {
         for (let i in middlewareOptions) {
             Object.assign(middlewareOptions[i].options, globalOptions, middlewareOptions[i].localOptions);
         }
     }
 
+    /**
+     * Clear key from cache
+     * @param {string} target Key to clear
+     * @param {boolean} isAutomatic Is the key being cleared automatically
+     * @returns {number}
+     */
     this.clear = function (target, isAutomatic) {
         let group = index.groups[target];
         let redis = globalOptions.redisClient;
@@ -365,6 +471,14 @@ function ApiCache() {
         return this.getIndex();
     };
 
+    /**
+     * Converts a duration string to an integer number of milliseconds.
+     * @param {(string|number)} duration The string to convert.
+     * @param {number} defaultDuration The default duration to return if
+     * can't parse duration
+     * @returns {number} The converted value in milliseconds, or the
+     * defaultDuration if it can't be parsed.
+     */
     function parseDuration(duration, defaultDuration) {
         if (typeof duration === "number") {
             return duration;
@@ -387,17 +501,24 @@ function ApiCache() {
         return defaultDuration;
     }
 
+    /**
+     * Parse duration
+     * @param {(number|string)} duration
+     * @returns {number} Duration parsed to a number
+     */
     this.getDuration = function (duration) {
         return parseDuration(duration, globalOptions.defaultDuration);
     };
 
     /**
-   * Return cache performance statistics (hit rate).  Suitable for putting into a route:
+   * Return cache performance statistics (hit rate).  Suitable for
+   * putting into a route:
    * <code>
    * app.get('/api/cache/performance', (req, res) => {
    *    res.json(apicache.getPerformance())
    * })
    * </code>
+   * @returns {any[]}
    */
     this.getPerformance = function () {
         return performanceArray.map(function (p) {
@@ -405,6 +526,11 @@ function ApiCache() {
         });
     };
 
+    /**
+     * Get index of a group
+     * @param {string} group 
+     * @returns {number}
+     */
     this.getIndex = function (group) {
         if (group) {
             return index.groups[group];
@@ -413,6 +539,14 @@ function ApiCache() {
         }
     };
 
+    /**
+     * Express middleware
+     * @param {(string|number)} strDuration Duration to cache responses
+     * for.
+     * @param {function(Object, Object):boolean} middlewareToggle 
+     * @param {Object} localOptions Options for APICache
+     * @returns 
+     */
     this.middleware = function cache(strDuration, middlewareToggle, localOptions) {
         let duration = instance.getDuration(strDuration);
         let opt = {};
@@ -436,63 +570,72 @@ function ApiCache() {
         options(localOptions);
 
         /**
-     * A Function for non tracking performance
-     */
+         * A Function for non tracking performance
+         */
         function NOOPCachePerformance() {
             this.report = this.hit = this.miss = function () {}; // noop;
         }
 
         /**
-     * A function for tracking and reporting hit rate.  These statistics are returned by the getPerformance() call above.
-     */
+         * A function for tracking and reporting hit rate.  These
+         * statistics are returned by the getPerformance() call above.
+         */
         function CachePerformance() {
             /**
-       * Tracks the hit rate for the last 100 requests.
-       * If there have been fewer than 100 requests, the hit rate just considers the requests that have happened.
-       */
+             * Tracks the hit rate for the last 100 requests. If there
+             * have been fewer than 100 requests, the hit rate just
+             * considers the requests that have happened.
+             */
             this.hitsLast100 = new Uint8Array(100 / 4); // each hit is 2 bits
 
             /**
-       * Tracks the hit rate for the last 1000 requests.
-       * If there have been fewer than 1000 requests, the hit rate just considers the requests that have happened.
-       */
+             * Tracks the hit rate for the last 1000 requests. If there
+             * have been fewer than 1000 requests, the hit rate just
+             * considers the requests that have happened.
+             */
             this.hitsLast1000 = new Uint8Array(1000 / 4); // each hit is 2 bits
 
             /**
-       * Tracks the hit rate for the last 10000 requests.
-       * If there have been fewer than 10000 requests, the hit rate just considers the requests that have happened.
-       */
+             * Tracks the hit rate for the last 10000 requests. If there
+             * have been fewer than 10000 requests, the hit rate just
+             * considers the requests that have happened.
+             */
             this.hitsLast10000 = new Uint8Array(10000 / 4); // each hit is 2 bits
 
             /**
-       * Tracks the hit rate for the last 100000 requests.
-       * If there have been fewer than 100000 requests, the hit rate just considers the requests that have happened.
-       */
+             * Tracks the hit rate for the last 100000 requests. If
+             * there have been fewer than 100000 requests, the hit rate
+             * just considers the requests that have happened.
+             */
             this.hitsLast100000 = new Uint8Array(100000 / 4); // each hit is 2 bits
 
             /**
-       * The number of calls that have passed through the middleware since the server started.
-       */
+             * The number of calls that have passed through the
+             * middleware since the server started.
+             */
             this.callCount = 0;
 
             /**
-       * The total number of hits since the server started
-       */
+             * The total number of hits since the server started
+             */
             this.hitCount = 0;
 
             /**
-       * The key from the last cache hit.  This is useful in identifying which route these statistics apply to.
-       */
+             * The key from the last cache hit.  This is useful in
+             * identifying which route these statistics apply to.
+             */
             this.lastCacheHit = null;
 
             /**
-       * The key from the last cache miss.  This is useful in identifying which route these statistics apply to.
-       */
+             * The key from the last cache miss.  This is useful in
+             * identifying which route these statistics apply to.
+             */
             this.lastCacheMiss = null;
 
             /**
-       * Return performance statistics
-       */
+             * Return performance statistics
+             * @returns {Object}
+             */
             this.report = function () {
                 return {
                     lastCacheHit: this.lastCacheHit,
@@ -509,10 +652,13 @@ function ApiCache() {
             };
 
             /**
-       * Computes a cache hit rate from an array of hits and misses.
-       * @param {Uint8Array} array An array representing hits and misses.
-       * @returns a number between 0 and 1, or null if the array has no hits or misses
-       */
+             * Computes a cache hit rate from an array of hits and
+             * misses.
+             * @param {Uint8Array} array An array representing hits and
+             * misses.
+             * @returns {?number} a number between 0 and 1, or null if
+             * the array has no hits or misses
+             */
             this.hitRate = function (array) {
                 let hits = 0;
                 let misses = 0;
@@ -538,16 +684,17 @@ function ApiCache() {
             };
 
             /**
-       * Record a hit or miss in the given array.  It will be recorded at a position determined
-       * by the current value of the callCount variable.
-       * @param {Uint8Array} array An array representing hits and misses.
-       * @param {boolean} hit true for a hit, false for a miss
-       * Each element in the array is 8 bits, and encodes 4 hit/miss records.
-       * Each hit or miss is encoded as to bits as follows:
-       * 00 means no hit or miss has been recorded in these bits
-       * 01 encodes a hit
-       * 10 encodes a miss
-       */
+             * Record a hit or miss in the given array.  It will be
+             * recorded at a position determined by the current value of
+             * the callCount variable.
+             * @param {Uint8Array} array An array representing hits and
+             * misses.
+             * @param {boolean} hit true for a hit, false for a miss
+             * Each element in the array is 8 bits, and encodes 4
+             * hit/miss records. Each hit or miss is encoded as to bits
+             * as follows: 00 means no hit or miss has been recorded in
+             * these bits 01 encodes a hit 10 encodes a miss
+             */
             this.recordHitInArray = function (array, hit) {
                 let arrayIndex = ~~(this.callCount / 4) % array.length;
                 let bitOffset = (this.callCount % 4) * 2; // 2 bits per record, 4 records per uint8 array element
@@ -557,9 +704,11 @@ function ApiCache() {
             };
 
             /**
-       * Records the hit or miss in the tracking arrays and increments the call count.
-       * @param {boolean} hit true records a hit, false records a miss
-       */
+             * Records the hit or miss in the tracking arrays and
+             * increments the call count.
+             * @param {boolean} hit true records a hit, false records a
+             * miss
+             */
             this.recordHit = function (hit) {
                 this.recordHitInArray(this.hitsLast100, hit);
                 this.recordHitInArray(this.hitsLast1000, hit);
@@ -572,18 +721,18 @@ function ApiCache() {
             };
 
             /**
-       * Records a hit event, setting lastCacheMiss to the given key
-       * @param {string} key The key that had the cache hit
-       */
+             * Records a hit event, setting lastCacheMiss to the given key
+             * @param {string} key The key that had the cache hit
+             */
             this.hit = function (key) {
                 this.recordHit(true);
                 this.lastCacheHit = key;
             };
 
             /**
-       * Records a miss event, setting lastCacheMiss to the given key
-       * @param {string} key The key that had the cache miss
-       */
+             * Records a miss event, setting lastCacheMiss to the given key
+             * @param {string} key The key that had the cache miss
+             */
             this.miss = function (key) {
                 this.recordHit(false);
                 this.lastCacheMiss = key;
@@ -594,6 +743,13 @@ function ApiCache() {
 
         performanceArray.push(perf);
 
+        /**
+         * Cache a request
+         * @param {Object} req Express request object
+         * @param {Object} res Express response object
+         * @param {function} next Function to call next
+         * @returns {any}
+         */
         let cache = function (req, res, next) {
             function bypass() {
                 debug("bypass detected, skipping cache.");
@@ -701,6 +857,11 @@ function ApiCache() {
         return cache;
     };
 
+    /**
+     * Process options
+     * @param {Object} options 
+     * @returns {Object}
+     */
     this.options = function (options) {
         if (options) {
             Object.assign(globalOptions, options);
@@ -721,6 +882,7 @@ function ApiCache() {
         }
     };
 
+    /** Reset the index */
     this.resetIndex = function () {
         index = {
             all: [],
@@ -728,6 +890,11 @@ function ApiCache() {
         };
     };
 
+    /**
+     * Create a new instance of ApiCache
+     * @param {Object} config Config to pass
+     * @returns {ApiCache}
+     */
     this.newInstance = function (config) {
         let instance = new ApiCache();
 
@@ -738,6 +905,7 @@ function ApiCache() {
         return instance;
     };
 
+    /** Clone this instance */
     this.clone = function () {
         return this.newInstance(this.options());
     };

server/modules/apicache/memory-cache.js

@@ -3,6 +3,15 @@ function MemoryCache() {
     this.size = 0;
 }
 
+/**
+ * 
+ * @param {string} key Key to store cache as
+ * @param {any} value Value to store
+ * @param {number} time Time to store for
+ * @param {function(any, string)} timeoutCallback Callback to call in
+ * case of timeout
+ * @returns {Object}
+ */
 MemoryCache.prototype.add = function (key, value, time, timeoutCallback) {
     let old = this.cache[key];
     let instance = this;
@@ -22,6 +31,11 @@ MemoryCache.prototype.add = function (key, value, time, timeoutCallback) {
     return entry;
 };
 
+/**
+ * Delete a cache entry
+ * @param {string} key Key to delete
+ * @returns {null}
+ */
 MemoryCache.prototype.delete = function (key) {
     let entry = this.cache[key];
 
@@ -36,18 +50,32 @@ MemoryCache.prototype.delete = function (key) {
     return null;
 };
 
+/**
+ * Get value of key
+ * @param {string} key 
+ * @returns {Object}
+ */
 MemoryCache.prototype.get = function (key) {
     let entry = this.cache[key];
 
     return entry;
 };
 
+/**
+ * Get value of cache entry
+ * @param {string} key 
+ * @returns {any}
+ */
 MemoryCache.prototype.getValue = function (key) {
     let entry = this.get(key);
 
     return entry && entry.value;
 };
 
+/**
+ * Clear cache
+ * @returns {boolean}
+ */
 MemoryCache.prototype.clear = function () {
     Object.keys(this.cache).forEach(function (key) {
         this.delete(key);

server/modules/dayjs/plugin/timezone.d.ts

@@ -0,0 +1,20 @@
+import { PluginFunc, ConfigType } from 'dayjs'
+
+declare const plugin: PluginFunc
+export = plugin
+
+declare module 'dayjs' {
+  interface Dayjs {
+    tz(timezone?: string, keepLocalTime?: boolean): Dayjs
+    offsetName(type?: 'short' | 'long'): string | undefined
+  }
+
+  interface DayjsTimezone {
+    (date: ConfigType, timezone?: string): Dayjs
+    (date: ConfigType, format: string, timezone?: string): Dayjs
+    guess(): string
+    setDefault(timezone?: string): void
+  }
+
+  const tz: DayjsTimezone
+}

server/modules/dayjs/plugin/timezone.js

@@ -0,0 +1,115 @@
+/**
+ * Copy from node_modules/dayjs/plugin/timezone.js
+ * Try to fix https://github.com/louislam/uptime-kuma/issues/2318
+ * Source: https://github.com/iamkun/dayjs/tree/dev/src/plugin/utc
+ * License: MIT
+ */
+!function (t, e) {
+    // eslint-disable-next-line no-undef
+    typeof exports == "object" && typeof module != "undefined" ? module.exports = e() : typeof define == "function" && define.amd ? define(e) : (t = typeof globalThis != "undefined" ? globalThis : t || self).dayjs_plugin_timezone = e();
+}(this, (function () {
+    "use strict";
+    let t = {
+        year: 0,
+        month: 1,
+        day: 2,
+        hour: 3,
+        minute: 4,
+        second: 5
+    };
+    let e = {};
+    return function (n, i, o) {
+        let r;
+        let a = function (t, n, i) {
+            void 0 === i && (i = {});
+            let o = new Date(t);
+            let r = function (t, n) {
+                void 0 === n && (n = {});
+                let i = n.timeZoneName || "short";
+                let o = t + "|" + i;
+                let r = e[o];
+                return r || (r = new Intl.DateTimeFormat("en-US", {
+                    hour12: !1,
+                    timeZone: t,
+                    year: "numeric",
+                    month: "2-digit",
+                    day: "2-digit",
+                    hour: "2-digit",
+                    minute: "2-digit",
+                    second: "2-digit",
+                    timeZoneName: i
+                }), e[o] = r), r;
+            }(n, i);
+            return r.formatToParts(o);
+        };
+        let u = function (e, n) {
+            let i = a(e, n);
+            let r = [];
+            let u = 0;
+            for (; u < i.length; u += 1) {
+                let f = i[u];
+                let s = f.type;
+                let m = f.value;
+                let c = t[s];
+                c >= 0 && (r[c] = parseInt(m, 10));
+            }
+            let d = r[3];
+            let l = d === 24 ? 0 : d;
+            let v = r[0] + "-" + r[1] + "-" + r[2] + " " + l + ":" + r[4] + ":" + r[5] + ":000";
+            let h = +e;
+            return (o.utc(v).valueOf() - (h -= h % 1e3)) / 6e4;
+        };
+        let f = i.prototype;
+        f.tz = function (t, e) {
+            void 0 === t && (t = r);
+            let n = this.utcOffset();
+            let i = this.toDate();
+            let a = i.toLocaleString("en-US", { timeZone: t }).replace("\u202f", " ");
+            let u = Math.round((i - new Date(a)) / 1e3 / 60);
+            let f = o(a).$set("millisecond", this.$ms).utcOffset(15 * -Math.round(i.getTimezoneOffset() / 15) - u, !0);
+            if (e) {
+                let s = f.utcOffset();
+                f = f.add(n - s, "minute");
+            }
+            return f.$x.$timezone = t, f;
+        }, f.offsetName = function (t) {
+            let e = this.$x.$timezone || o.tz.guess();
+            let n = a(this.valueOf(), e, { timeZoneName: t }).find((function (t) {
+                return t.type.toLowerCase() === "timezonename";
+            }));
+            return n && n.value;
+        };
+        let s = f.startOf;
+        f.startOf = function (t, e) {
+            if (!this.$x || !this.$x.$timezone) {
+                return s.call(this, t, e);
+            }
+            let n = o(this.format("YYYY-MM-DD HH:mm:ss:SSS"));
+            return s.call(n, t, e).tz(this.$x.$timezone, !0);
+        }, o.tz = function (t, e, n) {
+            let i = n && e;
+            let a = n || e || r;
+            let f = u(+o(), a);
+            if (typeof t != "string") {
+                return o(t).tz(a);
+            }
+            let s = function (t, e, n) {
+                let i = t - 60 * e * 1e3;
+                let o = u(i, n);
+                if (e === o) {
+                    return [ i, e ];
+                }
+                let r = u(i -= 60 * (o - e) * 1e3, n);
+                return o === r ? [ i, o ] : [ t - 60 * Math.min(o, r) * 1e3, Math.max(o, r) ];
+            }(o.utc(t, i).valueOf(), f, a);
+            let m = s[0];
+            let c = s[1];
+            let d = o(m).utcOffset(c);
+            return d.$x.$timezone = a, d;
+        }, o.tz.guess = function () {
+            return Intl.DateTimeFormat().resolvedOptions().timeZone;
+        }, o.tz.setDefault = function (t) {
+            r = t;
+        };
+    };
+}));

server/monitor-types/monitor-type.js

@@ -0,0 +1,19 @@
+class MonitorType {
+
+    name = undefined;
+
+    /**
+     *
+     * @param {Monitor} monitor
+     * @param {Heartbeat} heartbeat
+     * @returns {Promise<void>}
+     */
+    async check(monitor, heartbeat) {
+        throw new Error("You need to override check()");
+    }
+
+}
+
+module.exports = {
+    MonitorType,
+};

server/notification-providers/alerta.js

@@ -0,0 +1,67 @@
+const NotificationProvider = require("./notification-provider");
+const { DOWN, UP } = require("../../src/util");
+const axios = require("axios");
+
+class Alerta extends NotificationProvider {
+
+    name = "alerta";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+
+        try {
+            let alertaUrl = `${notification.alertaApiEndpoint}`;
+            let config = {
+                headers: {
+                    "Content-Type": "application/json;charset=UTF-8",
+                    "Authorization": "Key " + notification.alertaApiKey,
+                }
+            };
+            let data = {
+                environment: notification.alertaEnvironment,
+                severity: "critical",
+                correlate: [],
+                service: [ "UptimeKuma" ],
+                value: "Timeout",
+                tags: [ "uptimekuma" ],
+                attributes: {},
+                origin: "uptimekuma",
+                type: "exceptionAlert",
+            };
+
+            if (heartbeatJSON == null) {
+                let postData = Object.assign({
+                    event: "msg",
+                    text: msg,
+                    group: "uptimekuma-msg",
+                    resource: "Message",
+                }, data);
+
+                await axios.post(alertaUrl, postData, config);
+            } else {
+                let datadup = Object.assign( {
+                    correlate: [ "service_up", "service_down" ],
+                    event: monitorJSON["type"],
+                    group: "uptimekuma-" + monitorJSON["type"],
+                    resource: monitorJSON["name"],
+                }, data );
+
+                if (heartbeatJSON["status"] === DOWN) {
+                    datadup.severity = notification.alertaAlertState; // critical
+                    datadup.text = "Service " + monitorJSON["type"] + " is down.";
+                    await axios.post(alertaUrl, datadup, config);
+                } else if (heartbeatJSON["status"] === UP) {
+                    datadup.severity = notification.alertaRecoverState; // cleaned
+                    datadup.text = "Service " + monitorJSON["type"] + " is up.";
+                    await axios.post(alertaUrl, datadup, config);
+                }
+            }
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+
+    }
+}
+
+module.exports = Alerta;

server/notification-providers/alertnow.js

@@ -0,0 +1,50 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const { setting } = require("../util-server");
+const { getMonitorRelativeURL, UP, DOWN } = require("../../src/util");
+
+class AlertNow extends NotificationProvider {
+
+    name = "AlertNow";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+        try {
+            let textMsg = "";
+            let status = "open";
+            let eventType = "ERROR";
+            let eventId = new Date().toISOString().slice(0, 10).replace(/-/g, "");
+
+            if (heartbeatJSON && heartbeatJSON.status === UP) {
+                textMsg = `[${heartbeatJSON.name}] ✅ Application is back online`;
+                status = "close";
+                eventType = "INFO";
+                eventId += `_${heartbeatJSON.name.replace(/\s/g, "")}`;
+            } else if (heartbeatJSON && heartbeatJSON.status === DOWN) {
+                textMsg = `[${heartbeatJSON.name}] 🔴 Application went down`;
+            }
+
+            textMsg += ` - ${msg}`;
+
+            const baseURL = await setting("primaryBaseURL");
+            if (baseURL && monitorJSON) {
+                textMsg += ` >> ${baseURL + getMonitorRelativeURL(monitorJSON.id)}`;
+            }
+
+            const data = {
+                "summary": textMsg,
+                "status": status,
+                "event_type": eventType,
+                "event_id": eventId,
+            };
+
+            await axios.post(notification.alertNowWebhookURL, data);
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+
+    }
+}
+
+module.exports = AlertNow;

server/notification-providers/aliyun-sms.js

@@ -37,6 +37,12 @@ class AliyunSMS extends NotificationProvider {
         }
     }
 
+    /**
+     * Send the SMS notification
+     * @param {BeanModel} notification Notification details
+     * @param {string} msgbody Message template
+     * @returns {boolean} True if successful else false
+     */
     async sendSms(notification, msgbody) {
         let params = {
             PhoneNumbers: notification.phonenumber,
@@ -64,13 +70,18 @@ class AliyunSMS extends NotificationProvider {
         };
 
         let result = await axios(config);
-        if (result.data.Message == "OK") {
+        if (result.data.Message === "OK") {
             return true;
         }
         return false;
     }
 
-    /** Aliyun request sign */
+    /**
+     * Aliyun request sign
+     * @param {Object} param Parameters object to sign
+     * @param {string} AccessKeySecret Secret key to sign parameters with
+     * @returns {string}
+     */
     sign(param, AccessKeySecret) {
         let param2 = {};
         let data = [];
@@ -82,8 +93,23 @@ class AliyunSMS extends NotificationProvider {
             param2[key] = param[key];
         }
 
+        // Escape more characters than encodeURIComponent does.
+        // For generating Aliyun signature, all characters except A-Za-z0-9~-._ are encoded.
+        // See https://help.aliyun.com/document_detail/315526.html
+        // This encoding methods as known as RFC 3986 (https://tools.ietf.org/html/rfc3986)
+        let moreEscapesTable = function (m) {
+            return {
+                "!": "%21",
+                "*": "%2A",
+                "'": "%27",
+                "(": "%28",
+                ")": "%29"
+            }[m];
+        };
+
         for (let key in param2) {
-            data.push(`${encodeURIComponent(key)}=${encodeURIComponent(param2[key])}`);
+            let value = encodeURIComponent(param2[key]).replace(/[!*'()]/g, moreEscapesTable);
+            data.push(`${encodeURIComponent(key)}=${value}`);
         }
 
         let StringToSign = `POST&${encodeURIComponent("/")}&${encodeURIComponent(data.join("&"))}`;
@@ -93,6 +119,11 @@ class AliyunSMS extends NotificationProvider {
             .digest("base64");
     }
 
+    /**
+     * Convert status constant to string
+     * @param {const} status The status constant
+     * @returns {string}
+     */
     statusToString(status) {
         switch (status) {
             case DOWN:

server/notification-providers/apprise.js

@@ -1,14 +1,19 @@
 const NotificationProvider = require("./notification-provider");
-const child_process = require("child_process");
+const childProcess = require("child_process");
 
 class Apprise extends NotificationProvider {
 
     name = "apprise";
 
     async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
-        let s = child_process.spawnSync("apprise", [ "-vv", "-b", msg, notification.appriseURL])
+        const args = [ "-vv", "-b", msg, notification.appriseURL ];
+        if (notification.title) {
+            args.push("-t");
+            args.push(notification.title);
+        }
+        const s = childProcess.spawnSync("apprise", args);
 
-        let output = (s.stdout) ? s.stdout.toString() : "ERROR: maybe apprise not found";
+        const output = (s.stdout) ? s.stdout.toString() : "ERROR: maybe apprise not found";
 
         if (output) {
 
@@ -16,7 +21,7 @@ class Apprise extends NotificationProvider {
                 return "Sent Successfully";
             }
 
-            throw new Error(output)
+            throw new Error(output);
         } else {
             return "No output from apprise";
         }

server/notification-providers/bark.js

@@ -12,55 +12,67 @@ const { default: axios } = require("axios");
 
 // bark is an APN bridge that sends notifications to Apple devices.
 
-const barkNotificationGroup = "UptimeKuma";
 const barkNotificationAvatar = "https://github.com/louislam/uptime-kuma/raw/master/public/icon.png";
-const barkNotificationSound = "telegraph";
 const successMessage = "Successes!";
 
 class Bark extends NotificationProvider {
     name = "Bark";
 
     async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
-        try {
-            var barkEndpoint = notification.barkEndpoint;
+        let barkEndpoint = notification.barkEndpoint;
 
-            // check if the endpoint has a "/" suffix, if so, delete it first
-            if (barkEndpoint.endsWith("/")) {
-                barkEndpoint = barkEndpoint.substring(0, barkEndpoint.length - 1);
-            }
+        // check if the endpoint has a "/" suffix, if so, delete it first
+        if (barkEndpoint.endsWith("/")) {
+            barkEndpoint = barkEndpoint.substring(0, barkEndpoint.length - 1);
+        }
 
-            if (msg != null && heartbeatJSON != null && heartbeatJSON["status"] == UP) {
-                let title = "UptimeKuma Monitor Up";
-                return await this.postNotification(title, msg, barkEndpoint);
-            }
+        if (msg != null && heartbeatJSON != null && heartbeatJSON["status"] === UP) {
+            let title = "UptimeKuma Monitor Up";
+            return await this.postNotification(notification, title, msg, barkEndpoint);
+        }
 
-            if (msg != null && heartbeatJSON != null && heartbeatJSON["status"] == DOWN) {
-                let title = "UptimeKuma Monitor Down";
-                return await this.postNotification(title, msg, barkEndpoint);
-            }
+        if (msg != null && heartbeatJSON != null && heartbeatJSON["status"] === DOWN) {
+            let title = "UptimeKuma Monitor Down";
+            return await this.postNotification(notification, title, msg, barkEndpoint);
+        }
 
-            if (msg != null) {
-                let title = "UptimeKuma Message";
-                return await this.postNotification(title, msg, barkEndpoint);
-            }
-
-        } catch (error) {
-            throw error;
+        if (msg != null) {
+            let title = "UptimeKuma Message";
+            return await this.postNotification(notification, title, msg, barkEndpoint);
         }
     }
 
-    // add additional parameter for better on device styles (iOS 15 optimized)
-    appendAdditionalParameters(postUrl) {
-        // grouping all our notifications
-        postUrl += "?group=" + barkNotificationGroup;
+    /**
+     * Add additional parameter for better on device styles (iOS 15
+     * optimized)
+     * @param {string} postUrl URL to append parameters to
+     * @returns {string}
+     */
+    appendAdditionalParameters(notification, postUrl) {
         // set icon to uptime kuma icon, 11kb should be fine
-        postUrl += "&icon=" + barkNotificationAvatar;
+        postUrl += "?icon=" + barkNotificationAvatar;
+        // grouping all our notifications
+        if (notification.barkGroup != null) {
+            postUrl += "&group=" + notification.barkGroup;
+        } else {
+            // default name
+            postUrl += "&group=" + "UptimeKuma";
+        }
         // picked a sound, this should follow system's mute status when arrival
-        postUrl += "&sound=" + barkNotificationSound;
+        if (notification.barkSound != null) {
+            postUrl += "&sound=" + notification.barkSound;
+        } else {
+            // default sound
+            postUrl += "&sound=" + "telegraph";
+        }
         return postUrl;
     }
 
-    // thrown if failed to check result, result code should be in range 2xx
+    /**
+     * Check if result is successful
+     * @param {Object} result Axios response object
+     * @throws {Error} The status code is not in range 2xx
+     */
     checkResult(result) {
         if (result.status == null) {
             throw new Error("Bark notification failed with invalid response!");
@@ -70,12 +82,19 @@ class Bark extends NotificationProvider {
         }
     }
 
-    async postNotification(title, subtitle, endpoint) {
+    /**
+     * Send the message
+     * @param {string} title Message title
+     * @param {string} subtitle Message
+     * @param {string} endpoint Endpoint to send request to
+     * @returns {string}
+     */
+    async postNotification(notification, title, subtitle, endpoint) {
         // url encode title and subtitle
         title = encodeURIComponent(title);
         subtitle = encodeURIComponent(subtitle);
         let postUrl = endpoint + "/" + title + "/" + subtitle;
-        postUrl = this.appendAdditionalParameters(postUrl);
+        postUrl = this.appendAdditionalParameters(notification, postUrl);
         let result = await axios.get(postUrl);
         this.checkResult(result);
         if (result.statusText != null) {

server/notification-providers/clicksendsms.js

@@ -8,11 +8,10 @@ class ClickSendSMS extends NotificationProvider {
     async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
         let okMsg = "Sent Successfully.";
         try {
-            console.log({ notification });
             let config = {
                 headers: {
                     "Content-Type": "application/json",
-                    "Authorization": "Basic " + Buffer.from(notification.clicksendsmsLogin + ":" + notification.clicksendsmsPassword).toString('base64'),
+                    "Authorization": "Basic " + Buffer.from(notification.clicksendsmsLogin + ":" + notification.clicksendsmsPassword).toString("base64"),
                     "Accept": "text/json",
                 }
             };

server/notification-providers/dingding.js

@@ -37,6 +37,12 @@ class DingDing extends NotificationProvider {
         }
     }
 
+    /**
+     * Send message to DingDing
+     * @param {BeanModel} notification
+     * @param {Object} params Parameters of message
+     * @returns {boolean} True if successful else false
+     */
     async sendToDingDing(notification, params) {
         let timestamp = Date.now();
 
@@ -50,13 +56,18 @@ class DingDing extends NotificationProvider {
         };
 
         let result = await axios(config);
-        if (result.data.errmsg == "ok") {
+        if (result.data.errmsg === "ok") {
             return true;
         }
         return false;
     }
 
-    /** DingDing sign */
+    /**
+     * DingDing sign
+     * @param {Date} timestamp Timestamp of message
+     * @param {string} secretKey Secret key to sign data with
+     * @returns {string}
+     */
     sign(timestamp, secretKey) {
         return Crypto
             .createHmac("sha256", Buffer.from(secretKey, "utf8"))
@@ -64,7 +75,13 @@ class DingDing extends NotificationProvider {
             .digest("base64");
     }
 
+    /**
+     * Convert status constant to string
+     * @param {const} status The status constant
+     * @returns {string}
+     */
     statusToString(status) {
+        // TODO: Move to notification-provider.js to avoid repetition in classes
         switch (status) {
             case DOWN:
                 return "DOWN";

server/notification-providers/discord.js

@@ -17,25 +17,32 @@ class Discord extends NotificationProvider {
                 let discordtestdata = {
                     username: discordDisplayName,
                     content: msg,
-                }
-                await axios.post(notification.discordWebhookUrl, discordtestdata)
+                };
+                await axios.post(notification.discordWebhookUrl, discordtestdata);
                 return okMsg;
             }
 
-            let url;
+            let address;
 
-            if (monitorJSON["type"] === "port") {
-                url = monitorJSON["hostname"];
-                if (monitorJSON["port"]) {
-                    url += ":" + monitorJSON["port"];
-                }
-
-            } else {
-                url = monitorJSON["url"];
+            switch (monitorJSON["type"]) {
+                case "ping":
+                    address = monitorJSON["hostname"];
+                    break;
+                case "port":
+                case "dns":
+                case "steam":
+                    address = monitorJSON["hostname"];
+                    if (monitorJSON["port"]) {
+                        address += ":" + monitorJSON["port"];
+                    }
+                    break;
+                default:
+                    address = monitorJSON["url"];
+                    break;
             }
 
             // If heartbeatJSON is not null, we go into the normal alerting loop.
-            if (heartbeatJSON["status"] == DOWN) {
+            if (heartbeatJSON["status"] === DOWN) {
                 let discorddowndata = {
                     username: discordDisplayName,
                     embeds: [{
@@ -48,8 +55,8 @@ class Discord extends NotificationProvider {
                                 value: monitorJSON["name"],
                             },
                             {
-                                name: "Service URL",
-                                value: url,
+                                name: monitorJSON["type"] === "push" ? "Service Type" : "Service URL",
+                                value: monitorJSON["type"] === "push" ? "Heartbeat" : address,
                             },
                             {
                                 name: "Time (UTC)",
@@ -57,20 +64,20 @@ class Discord extends NotificationProvider {
                             },
                             {
                                 name: "Error",
-                                value: heartbeatJSON["msg"],
+                                value: heartbeatJSON["msg"] == null ? "N/A" : heartbeatJSON["msg"],
                             },
                         ],
                     }],
-                }
+                };
 
                 if (notification.discordPrefixMessage) {
                     discorddowndata.content = notification.discordPrefixMessage;
                 }
 
-                await axios.post(notification.discordWebhookUrl, discorddowndata)
+                await axios.post(notification.discordWebhookUrl, discorddowndata);
                 return okMsg;
 
-            } else if (heartbeatJSON["status"] == UP) {
+            } else if (heartbeatJSON["status"] === UP) {
                 let discordupdata = {
                     username: discordDisplayName,
                     embeds: [{
@@ -83,8 +90,8 @@ class Discord extends NotificationProvider {
                                 value: monitorJSON["name"],
                             },
                             {
-                                name: "Service URL",
-                                value: url.startsWith("http") ? "[Visit Service](" + url + ")" : url,
+                                name: monitorJSON["type"] === "push" ? "Service Type" : "Service URL",
+                                value: monitorJSON["type"] === "push" ? "Heartbeat" : address,
                             },
                             {
                                 name: "Time (UTC)",
@@ -92,21 +99,21 @@ class Discord extends NotificationProvider {
                             },
                             {
                                 name: "Ping",
-                                value: heartbeatJSON["ping"] + "ms",
+                                value: heartbeatJSON["ping"] == null ? "N/A" : heartbeatJSON["ping"] + " ms",
                             },
                         ],
                     }],
-                }
+                };
 
                 if (notification.discordPrefixMessage) {
                     discordupdata.content = notification.discordPrefixMessage;
                 }
 
-                await axios.post(notification.discordWebhookUrl, discordupdata)
+                await axios.post(notification.discordWebhookUrl, discordupdata);
                 return okMsg;
             }
         } catch (error) {
-            this.throwGeneralAxiosError(error)
+            this.throwGeneralAxiosError(error);
         }
     }
 

server/notification-providers/feishu.js

@@ -21,7 +21,7 @@ class Feishu extends NotificationProvider {
                 return okMsg;
             }
 
-            if (heartbeatJSON["status"] == DOWN) {
+            if (heartbeatJSON["status"] === DOWN) {
                 let downdata = {
                     msg_type: "post",
                     content: {
@@ -48,7 +48,7 @@ class Feishu extends NotificationProvider {
                 return okMsg;
             }
 
-            if (heartbeatJSON["status"] == UP) {
+            if (heartbeatJSON["status"] === UP) {
                 let updata = {
                     msg_type: "post",
                     content: {

server/notification-providers/freemobile.js

@@ -0,0 +1,24 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+class FreeMobile extends NotificationProvider {
+
+    name = "FreeMobile";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+        try {
+            await axios.post(`https://smsapi.free-mobile.fr/sendmsg?msg=${encodeURIComponent(msg.replace("🔴", "⛔️"))}`, {
+                "user": notification.freemobileUser,
+                "pass": notification.freemobilePass,
+            });
+
+            return okMsg;
+
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = FreeMobile;

server/notification-providers/goalert.js

@@ -0,0 +1,35 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const { UP } = require("../../src/util");
+
+class GoAlert extends NotificationProvider {
+
+    name = "GoAlert";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+        try {
+            let closeAction = "close";
+            let data = {
+                summary: msg,
+            };
+            if (heartbeatJSON != null && heartbeatJSON["status"] === UP) {
+                data["action"] = closeAction;
+            }
+            let headers = {
+                "Content-Type": "multipart/form-data",
+            };
+            let config = {
+                headers: headers
+            };
+            await axios.post(`${notification.goAlertBaseURL}/api/v2/generic/incoming?token=${notification.goAlertToken}`, data, config);
+            return okMsg;
+
+        } catch (error) {
+            let msg = (error.response.data) ? error.response.data : "Error without response";
+            throw new Error(msg);
+        }
+    }
+}
+
+module.exports = GoAlert;

server/notification-providers/google-chat.js

@@ -0,0 +1,47 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const { setting } = require("../util-server");
+const { getMonitorRelativeURL } = require("../../src/util");
+const { DOWN, UP } = require("../../src/util");
+
+class GoogleChat extends NotificationProvider {
+
+    name = "GoogleChat";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+        try {
+            // Google Chat message formatting: https://developers.google.com/chat/api/guides/message-formats/basic
+
+            let textMsg = "";
+            if (heartbeatJSON && heartbeatJSON.status === UP) {
+                textMsg = "✅ Application is back online\n";
+            } else if (heartbeatJSON && heartbeatJSON.status === DOWN) {
+                textMsg = "🔴 Application went down\n";
+            }
+
+            if (monitorJSON && monitorJSON.name) {
+                textMsg += `*${monitorJSON.name}*\n`;
+            }
+
+            textMsg += `${msg}`;
+
+            const baseURL = await setting("primaryBaseURL");
+            if (baseURL && monitorJSON) {
+                textMsg += `\n${baseURL + getMonitorRelativeURL(monitorJSON.id)}`;
+            }
+
+            const data = {
+                "text": textMsg,
+            };
+
+            await axios.post(notification.googleChatWebhookURL, data);
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+
+    }
+}
+
+module.exports = GoogleChat;

server/notification-providers/gorush.js

@@ -0,0 +1,42 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+class Gorush extends NotificationProvider {
+
+    name = "gorush";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+
+        let platformMapping = {
+            "ios": 1,
+            "android": 2,
+            "huawei": 3,
+        };
+
+        try {
+            let data = {
+                "notifications": [
+                    {
+                        "tokens": [ notification.gorushDeviceToken ],
+                        "platform": platformMapping[notification.gorushPlatform],
+                        "message": msg,
+                        // Optional
+                        "title": notification.gorushTitle,
+                        "priority": notification.gorushPriority,
+                        "retry": parseInt(notification.gorushRetry) || 0,
+                        "topic": notification.gorushTopic,
+                    }
+                ]
+            };
+            let config = {};
+
+            await axios.post(`${notification.gorushServerURL}/api/push`, data, config);
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = Gorush;

server/notification-providers/gotify.js

@@ -15,7 +15,7 @@ class Gotify extends NotificationProvider {
                 "message": msg,
                 "priority": notification.gotifyPriority || 8,
                 "title": "Uptime-Kuma",
-            })
+            });
 
             return okMsg;
 

server/notification-providers/home-assistant.js

@@ -0,0 +1,38 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+const defaultNotificationService = "notify";
+
+class HomeAssistant extends NotificationProvider {
+    name = "HomeAssistant";
+
+    async send(notification, message, monitor = null, heartbeat = null) {
+        const notificationService = notification?.notificationService || defaultNotificationService;
+
+        try {
+            await axios.post(
+                `${notification.homeAssistantUrl}/api/services/notify/${notificationService}`,
+                {
+                    title: "Uptime Kuma",
+                    message,
+                    ...(notificationService !== "persistent_notification" && { data: {
+                        name: monitor?.name,
+                        status: heartbeat?.status,
+                    } }),
+                },
+                {
+                    headers: {
+                        Authorization: `Bearer ${notification.longLivedAccessToken}`,
+                        "Content-Type": "application/json",
+                    },
+                }
+            );
+
+            return "Sent Successfully.";
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = HomeAssistant;

server/notification-providers/kook.js

@@ -0,0 +1,31 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+class Kook extends NotificationProvider {
+
+    name = "Kook";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+        let url = "https://www.kookapp.cn/api/v3/message/create";
+        let data = {
+            target_id: notification.kookGuildID,
+            content: msg,
+        };
+        let config = {
+            headers: {
+                "Authorization": "Bot " + notification.kookBotToken,
+                "Content-Type": "application/json",
+            },
+        };
+        try {
+            await axios.post(url, data, config);
+            return okMsg;
+
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = Kook;

server/notification-providers/line.js

@@ -25,9 +25,9 @@ class Line extends NotificationProvider {
                             "text": "Test Successful!"
                         }
                     ]
-                }
-                await axios.post(lineAPIUrl, testMessage, config)
-            } else if (heartbeatJSON["status"] == DOWN) {
+                };
+                await axios.post(lineAPIUrl, testMessage, config);
+            } else if (heartbeatJSON["status"] === DOWN) {
                 let downMessage = {
                     "to": notification.lineUserID,
                     "messages": [
@@ -36,9 +36,9 @@ class Line extends NotificationProvider {
                             "text": "UptimeKuma Alert: [🔴 Down]\n" + "Name: " + monitorJSON["name"] + " \n" + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"]
                         }
                     ]
-                }
-                await axios.post(lineAPIUrl, downMessage, config)
-            } else if (heartbeatJSON["status"] == UP) {
+                };
+                await axios.post(lineAPIUrl, downMessage, config);
+            } else if (heartbeatJSON["status"] === UP) {
                 let upMessage = {
                     "to": notification.lineUserID,
                     "messages": [
@@ -47,12 +47,12 @@ class Line extends NotificationProvider {
                             "text": "UptimeKuma Alert: [✅ Up]\n" + "Name: " + monitorJSON["name"] + " \n" + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"]
                         }
                     ]
-                }
-                await axios.post(lineAPIUrl, upMessage, config)
+                };
+                await axios.post(lineAPIUrl, upMessage, config);
             }
             return okMsg;
         } catch (error) {
-            this.throwGeneralAxiosError(error)
+            this.throwGeneralAxiosError(error);
         }
     }
 }

server/notification-providers/linenotify.js

@@ -0,0 +1,43 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const qs = require("qs");
+const { DOWN, UP } = require("../../src/util");
+
+class LineNotify extends NotificationProvider {
+
+    name = "LineNotify";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+        try {
+            let lineAPIUrl = "https://notify-api.line.me/api/notify";
+            let config = {
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    "Authorization": "Bearer " + notification.lineNotifyAccessToken
+                }
+            };
+            if (heartbeatJSON == null) {
+                let testMessage = {
+                    "message": msg,
+                };
+                await axios.post(lineAPIUrl, qs.stringify(testMessage), config);
+            } else if (heartbeatJSON["status"] === DOWN) {
+                let downMessage = {
+                    "message": "\n[🔴 Down]\n" + "Name: " + monitorJSON["name"] + " \n" + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"]
+                };
+                await axios.post(lineAPIUrl, qs.stringify(downMessage), config);
+            } else if (heartbeatJSON["status"] === UP) {
+                let upMessage = {
+                    "message": "\n[✅ Up]\n" + "Name: " + monitorJSON["name"] + " \n" + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"]
+                };
+                await axios.post(lineAPIUrl, qs.stringify(upMessage), config);
+            }
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = LineNotify;

server/notification-providers/lunasea.js

@@ -8,38 +8,38 @@ class LunaSea extends NotificationProvider {
 
     async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
         let okMsg = "Sent Successfully.";
-        let lunaseadevice = "https://notify.lunasea.app/v1/custom/device/" + notification.lunaseaDevice
+        let lunaseadevice = "https://notify.lunasea.app/v1/custom/device/" + notification.lunaseaDevice;
 
         try {
             if (heartbeatJSON == null) {
                 let testdata = {
                     "title": "Uptime Kuma Alert",
-                    "body": "Testing Successful.",
-                }
-                await axios.post(lunaseadevice, testdata)
+                    "body": msg,
+                };
+                await axios.post(lunaseadevice, testdata);
                 return okMsg;
             }
 
-            if (heartbeatJSON["status"] == DOWN) {
+            if (heartbeatJSON["status"] === DOWN) {
                 let downdata = {
                     "title": "UptimeKuma Alert: " + monitorJSON["name"],
                     "body": "[🔴 Down] " + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"],
-                }
-                await axios.post(lunaseadevice, downdata)
+                };
+                await axios.post(lunaseadevice, downdata);
                 return okMsg;
             }
 
-            if (heartbeatJSON["status"] == UP) {
+            if (heartbeatJSON["status"] === UP) {
                 let updata = {
                     "title": "UptimeKuma Alert: " + monitorJSON["name"],
                     "body": "[✅ Up] " + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"],
-                }
-                await axios.post(lunaseadevice, updata)
+                };
+                await axios.post(lunaseadevice, updata);
                 return okMsg;
             }
 
         } catch (error) {
-            this.throwGeneralAxiosError(error)
+            this.throwGeneralAxiosError(error);
         }
 
     }

server/notification-providers/matrix.js

@@ -1,7 +1,7 @@
 const NotificationProvider = require("./notification-provider");
 const axios = require("axios");
 const Crypto = require("crypto");
-const { debug } = require("../../src/util");
+const { log } = require("../../src/util");
 
 class Matrix extends NotificationProvider {
     name = "matrix";
@@ -17,11 +17,11 @@ class Matrix extends NotificationProvider {
                 .slice(0, size)
         );
 
-        debug("Random String: " + randomString);
+        log.debug("notification", "Random String: " + randomString);
 
         const roomId = encodeURIComponent(notification.internalRoomId);
 
-        debug("Matrix Room ID: " + roomId);
+        log.debug("notification", "Matrix Room ID: " + roomId);
 
         try {
             let config = {

server/notification-providers/mattermost.js

@@ -15,16 +15,21 @@ class Mattermost extends NotificationProvider {
                 let mattermostTestData = {
                     username: mattermostUserName,
                     text: msg,
-                }
-                await axios.post(notification.mattermostWebhookUrl, mattermostTestData)
+                };
+                await axios.post(notification.mattermostWebhookUrl, mattermostTestData);
                 return okMsg;
             }
 
-            const mattermostChannel = notification.mattermostchannel;
+            let mattermostChannel;
+
+            if (typeof notification.mattermostchannel === "string") {
+                mattermostChannel = notification.mattermostchannel.toLowerCase();
+            }
+
             const mattermostIconEmoji = notification.mattermosticonemo;
             const mattermostIconUrl = notification.mattermosticonurl;
 
-            if (heartbeatJSON["status"] == DOWN) {
+            if (heartbeatJSON["status"] === DOWN) {
                 let mattermostdowndata = {
                     username: mattermostUserName,
                     text: "Uptime Kuma Alert",
@@ -68,7 +73,7 @@ class Mattermost extends NotificationProvider {
                     mattermostdowndata
                 );
                 return okMsg;
-            } else if (heartbeatJSON["status"] == UP) {
+            } else if (heartbeatJSON["status"] === UP) {
                 let mattermostupdata = {
                     username: mattermostUserName,
                     text: "Uptime Kuma Alert",

server/notification-providers/notification-provider.js

@@ -7,17 +7,23 @@ class NotificationProvider {
     name = undefined;
 
     /**
-     * @param notification : BeanModel
-     * @param msg : string General Message
-     * @param monitorJSON : object Monitor details (For Up/Down only)
-     * @param heartbeatJSON : object Heartbeat details (For Up/Down only)
+     * Send a notification
+     * @param {BeanModel} notification
+     * @param {string} msg General Message
+     * @param {?Object} monitorJSON Monitor details (For Up/Down only)
+     * @param {?Object} heartbeatJSON Heartbeat details (For Up/Down only)
      * @returns {Promise<string>} Return Successful Message
-     * Throw Error with fail msg
+     * @throws Error with fail msg
      */
     async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
         throw new Error("Have to override Notification.send(...)");
     }
 
+    /**
+     * Throws an error
+     * @param {any} error The error to throw
+     * @throws {any} The error specified
+     */
     throwGeneralAxiosError(error) {
         let msg = "Error: " + error + " ";
 
@@ -25,11 +31,11 @@ class NotificationProvider {
             if (typeof error.response.data === "string") {
                 msg += error.response.data;
             } else {
-                msg += JSON.stringify(error.response.data)
+                msg += JSON.stringify(error.response.data);
             }
         }
 
-        throw new Error(msg)
+        throw new Error(msg);
     }
 }
 

server/notification-providers/ntfy.js

@@ -0,0 +1,38 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+class Ntfy extends NotificationProvider {
+
+    name = "ntfy";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+        try {
+            let headers = {};
+            if (notification.ntfyusername) {
+                headers = {
+                    "Authorization": "Basic " + Buffer.from(notification.ntfyusername + ":" + notification.ntfypassword).toString("base64"),
+                };
+            }
+            let data = {
+                "topic": notification.ntfytopic,
+                "message": msg,
+                "priority": notification.ntfyPriority || 4,
+                "title": "Uptime-Kuma",
+            };
+
+            if (notification.ntfyIcon) {
+                data.icon = notification.ntfyIcon;
+            }
+
+            await axios.post(`${notification.ntfyserverurl}`, data, { headers: headers });
+
+            return okMsg;
+
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = Ntfy;

server/notification-providers/octopush.js

@@ -10,7 +10,7 @@ class Octopush extends NotificationProvider {
 
         try {
         // Default - V2
-            if (notification.octopushVersion == 2 || !notification.octopushVersion) {
+            if (notification.octopushVersion === "2" || !notification.octopushVersion) {
                 let config = {
                     headers: {
                         "api-key": notification.octopushAPIKey,
@@ -30,14 +30,14 @@ class Octopush extends NotificationProvider {
                     "purpose": "alert",
                     "sender": notification.octopushSenderName
                 };
-                await axios.post("https://api.octopush.com/v1/public/sms-campaign/send", data, config)
-            } else if (notification.octopushVersion == 1) {
+                await axios.post("https://api.octopush.com/v1/public/sms-campaign/send", data, config);
+            } else if (notification.octopushVersion === "1") {
                 let data = {
                     "user_login": notification.octopushDMLogin,
                     "api_key": notification.octopushDMAPIKey,
                     "sms_recipients": notification.octopushDMPhoneNumber,
                     "sms_sender": notification.octopushDMSenderName,
-                    "sms_type": (notification.octopushDMSMSType == "sms_premium") ? "FR" : "XXX",
+                    "sms_type": (notification.octopushDMSMSType === "sms_premium") ? "FR" : "XXX",
                     "transactional": "1",
                     //octopush not supporting non ascii char
                     "sms_text": msg.replace(/[^\x00-\x7F]/g, ""),
@@ -49,7 +49,15 @@ class Octopush extends NotificationProvider {
                     },
                     params: data
                 };
-                await axios.post("https://www.octopush-dm.com/api/sms/json", {}, config)
+
+                // V1 API returns 200 even on error so we must check
+                // response data
+                let response = await axios.post("https://www.octopush-dm.com/api/sms/json", {}, config);
+                if ("error_code" in response.data) {
+                    if (response.data.error_code !== "000") {
+                        this.throwGeneralAxiosError(`Octopush error ${JSON.stringify(response.data)}`);
+                    }
+                }
             } else {
                 throw new Error("Unknown Octopush version!");
             }

server/notification-providers/onebot.js

@@ -0,0 +1,45 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+class OneBot extends NotificationProvider {
+
+    name = "OneBot";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+        try {
+            let httpAddr = notification.httpAddr;
+            if (!httpAddr.startsWith("http")) {
+                httpAddr = "http://" + httpAddr;
+            }
+            if (!httpAddr.endsWith("/")) {
+                httpAddr += "/";
+            }
+            let onebotAPIUrl = httpAddr + "send_msg";
+            let config = {
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": "Bearer " + notification.accessToken,
+                }
+            };
+            let pushText = "UptimeKuma Alert: " + msg;
+            let data = {
+                "auto_escape": true,
+                "message": pushText,
+            };
+            if (notification.msgType === "group") {
+                data["message_type"] = "group";
+                data["group_id"] = notification.recieverId;
+            } else {
+                data["message_type"] = "private";
+                data["user_id"] = notification.recieverId;
+            }
+            await axios.post(onebotAPIUrl, data, config);
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = OneBot;

server/notification-providers/pagerduty.js

@@ -0,0 +1,113 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const { UP, DOWN, getMonitorRelativeURL } = require("../../src/util");
+const { setting } = require("../util-server");
+let successMessage = "Sent Successfully.";
+
+class PagerDuty extends NotificationProvider {
+    name = "PagerDuty";
+
+    /**
+     * @inheritdoc
+     */
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        try {
+            if (heartbeatJSON == null) {
+                const title = "Uptime Kuma Alert";
+                const monitor = {
+                    type: "ping",
+                    url: "Uptime Kuma Test Button",
+                };
+                return this.postNotification(notification, title, msg, monitor);
+            }
+
+            if (heartbeatJSON.status === UP) {
+                const title = "Uptime Kuma Monitor ✅ Up";
+                const eventAction = notification.pagerdutyAutoResolve || null;
+
+                return this.postNotification(notification, title, heartbeatJSON.msg, monitorJSON, eventAction);
+            }
+
+            if (heartbeatJSON.status === DOWN) {
+                const title = "Uptime Kuma Monitor 🔴 Down";
+                return this.postNotification(notification, title, heartbeatJSON.msg, monitorJSON, "trigger");
+            }
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+
+    /**
+     * Check if result is successful, result code should be in range 2xx
+     * @param {Object} result Axios response object
+     * @throws {Error} The status code is not in range 2xx
+     */
+    checkResult(result) {
+        if (result.status == null) {
+            throw new Error("PagerDuty notification failed with invalid response!");
+        }
+        if (result.status < 200 || result.status >= 300) {
+            throw new Error("PagerDuty notification failed with status code " + result.status);
+        }
+    }
+
+    /**
+     * Send the message
+     * @param {BeanModel} notification Message title
+     * @param {string} title Message title
+     * @param {string} body Message
+     * @param {Object} monitorInfo Monitor details (For Up/Down only)
+     * @param {?string} eventAction Action event for PagerDuty (trigger, acknowledge, resolve)
+     * @returns {string}
+     */
+    async postNotification(notification, title, body, monitorInfo, eventAction = "trigger") {
+
+        if (eventAction == null) {
+            return "No action required";
+        }
+
+        let monitorUrl;
+        if (monitorInfo.type === "port") {
+            monitorUrl = monitorInfo.hostname;
+            if (monitorInfo.port) {
+                monitorUrl += ":" + monitorInfo.port;
+            }
+        } else if (monitorInfo.hostname != null) {
+            monitorUrl = monitorInfo.hostname;
+        } else {
+            monitorUrl = monitorInfo.url;
+        }
+
+        const options = {
+            method: "POST",
+            url: notification.pagerdutyIntegrationUrl,
+            headers: { "Content-Type": "application/json" },
+            data: {
+                payload: {
+                    summary: `[${title}] [${monitorInfo.name}] ${body}`,
+                    severity: notification.pagerdutyPriority || "warning",
+                    source: monitorUrl,
+                },
+                routing_key: notification.pagerdutyIntegrationKey,
+                event_action: eventAction,
+                dedup_key: "Uptime Kuma/" + monitorInfo.id,
+            }
+        };
+
+        const baseURL = await setting("primaryBaseURL");
+        if (baseURL && monitorInfo) {
+            options.client = "Uptime Kuma";
+            options.client_url = baseURL + getMonitorRelativeURL(monitorInfo.id);
+        }
+
+        let result = await axios.request(options);
+        this.checkResult(result);
+        if (result.statusText != null) {
+            return "PagerDuty notification succeed: " + result.statusText;
+        }
+
+        return successMessage;
+    }
+}
+
+module.exports = PagerDuty;

server/notification-providers/promosms.js

@@ -8,18 +8,27 @@ class PromoSMS extends NotificationProvider {
     async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
         let okMsg = "Sent Successfully.";
 
+        if (notification.promosmsAllowLongSMS === undefined) {
+            notification.promosmsAllowLongSMS = false;
+        }
+
+        //TODO: Add option for enabling special characters. It will decrese message max length from 160 to 70 chars.
+        //Lets remove non ascii char
+        let cleanMsg = msg.replace(/[^\x00-\x7F]/g, "");
+
         try {
             let config = {
                 headers: {
                     "Content-Type": "application/json",
-                    "Authorization": "Basic " + Buffer.from(notification.promosmsLogin + ":" + notification.promosmsPassword).toString('base64'),
+                    "Authorization": "Basic " + Buffer.from(notification.promosmsLogin + ":" + notification.promosmsPassword).toString("base64"),
                     "Accept": "text/json",
                 }
             };
             let data = {
                 "recipients": [ notification.promosmsPhoneNumber ],
-                //Lets remove non ascii char
-                "text": msg.replace(/[^\x00-\x7F]/g, ""),
+                //Trim message to maximum length of 1 SMS or 4 if we allowed long messages
+                "text": notification.promosmsAllowLongSMS ? cleanMsg.substring(0, 639) : cleanMsg.substring(0, 159),
+                "long-sms": notification.promosmsAllowLongSMS,
                 "type": Number(notification.promosmsSMSType),
                 "sender": notification.promosmsSenderName
             };
@@ -30,7 +39,7 @@ class PromoSMS extends NotificationProvider {
                 let error = "Something gone wrong. Api returned " + resp.data.response.status + ".";
                 this.throwGeneralAxiosError(error);
             }
-            
+
             return okMsg;
         } catch (error) {
             this.throwGeneralAxiosError(error);

server/notification-providers/pushbullet.js

@@ -19,30 +19,30 @@ class Pushbullet extends NotificationProvider {
                 }
             };
             if (heartbeatJSON == null) {
-                let testdata = {
+                let data = {
                     "type": "note",
                     "title": "Uptime Kuma Alert",
-                    "body": "Testing Successful.",
-                }
-                await axios.post(pushbulletUrl, testdata, config)
-            } else if (heartbeatJSON["status"] == DOWN) {
-                let downdata = {
+                    "body": msg,
+                };
+                await axios.post(pushbulletUrl, data, config);
+            } else if (heartbeatJSON["status"] === DOWN) {
+                let downData = {
                     "type": "note",
                     "title": "UptimeKuma Alert: " + monitorJSON["name"],
                     "body": "[🔴 Down] " + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"],
-                }
-                await axios.post(pushbulletUrl, downdata, config)
-            } else if (heartbeatJSON["status"] == UP) {
-                let updata = {
+                };
+                await axios.post(pushbulletUrl, downData, config);
+            } else if (heartbeatJSON["status"] === UP) {
+                let upData = {
                     "type": "note",
                     "title": "UptimeKuma Alert: " + monitorJSON["name"],
                     "body": "[✅ Up] " + heartbeatJSON["msg"] + "\nTime (UTC): " + heartbeatJSON["time"],
-                }
-                await axios.post(pushbulletUrl, updata, config)
+                };
+                await axios.post(pushbulletUrl, upData, config);
             }
             return okMsg;
         } catch (error) {
-            this.throwGeneralAxiosError(error)
+            this.throwGeneralAxiosError(error);
         }
     }
 }

server/notification-providers/pushdeer.js

@@ -0,0 +1,52 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const { DOWN, UP } = require("../../src/util");
+
+class PushDeer extends NotificationProvider {
+
+    name = "PushDeer";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+        let pushdeerlink = "https://api2.pushdeer.com/message/push";
+
+        let valid = msg != null && monitorJSON != null && heartbeatJSON != null;
+
+        let title;
+        if (valid && heartbeatJSON.status === UP) {
+            title = "## Uptime Kuma: " + monitorJSON.name + " up";
+        } else if (valid && heartbeatJSON.status === DOWN) {
+            title = "## Uptime Kuma: " + monitorJSON.name + " down";
+        } else {
+            title = "## Uptime Kuma Message";
+        }
+
+        let data = {
+            "pushkey": notification.pushdeerKey,
+            "text": title,
+            "desp": msg.replace(/\n/g, "\n\n"),
+            "type": "markdown",
+        };
+
+        try {
+            let res = await axios.post(pushdeerlink, data);
+
+            if ("error" in res.data) {
+                let error = res.data.error;
+                this.throwGeneralAxiosError(error);
+            }
+            if (res.data.content.result.length === 0) {
+                let error = "Invalid PushDeer key";
+                this.throwGeneralAxiosError(error);
+            } else if (JSON.parse(res.data.content.result[0]).success !== "ok") {
+                let error = "Unknown error";
+                this.throwGeneralAxiosError(error);
+            }
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = PushDeer;

server/notification-providers/pushover.js

@@ -9,36 +9,31 @@ class Pushover extends NotificationProvider {
         let okMsg = "Sent Successfully.";
         let pushoverlink = "https://api.pushover.net/1/messages.json";
 
+        let data = {
+            "message": msg,
+            "user": notification.pushoveruserkey,
+            "token": notification.pushoverapptoken,
+            "sound": notification.pushoversounds,
+            "priority": notification.pushoverpriority,
+            "title": notification.pushovertitle,
+            "retry": "30",
+            "expire": "3600",
+            "html": 1,
+        };
+
+        if (notification.pushoverdevice) {
+            data.device = notification.pushoverdevice;
+        }
+
         try {
             if (heartbeatJSON == null) {
-                let data = {
-                    "message": msg,
-                    "user": notification.pushoveruserkey,
-                    "token": notification.pushoverapptoken,
-                    "sound": notification.pushoversounds,
-                    "priority": notification.pushoverpriority,
-                    "title": notification.pushovertitle,
-                    "retry": "30",
-                    "expire": "3600",
-                    "html": 1,
-                };
+                await axios.post(pushoverlink, data);
+                return okMsg;
+            } else {
+                data.message += "\n<b>Time (UTC)</b>:" + heartbeatJSON["time"];
                 await axios.post(pushoverlink, data);
                 return okMsg;
             }
-
-            let data = {
-                "message": "<b>Uptime Kuma Alert</b>\n\n<b>Message</b>:" + msg + "\n<b>Time (UTC)</b>:" + heartbeatJSON["time"],
-                "user": notification.pushoveruserkey,
-                "token": notification.pushoverapptoken,
-                "sound": notification.pushoversounds,
-                "priority": notification.pushoverpriority,
-                "title": notification.pushovertitle,
-                "retry": "30",
-                "expire": "3600",
-                "html": 1,
-            };
-            await axios.post(pushoverlink, data);
-            return okMsg;
         } catch (error) {
             this.throwGeneralAxiosError(error);
         }

server/notification-providers/pushy.js

@@ -19,10 +19,10 @@ class Pushy extends NotificationProvider {
                     "badge": 1,
                     "sound": "ping.aiff"
                 }
-            })
+            });
             return okMsg;
         } catch (error) {
-            this.throwGeneralAxiosError(error)
+            this.throwGeneralAxiosError(error);
         }
     }
 }

server/notification-providers/rocket-chat.js

@@ -2,7 +2,7 @@ const NotificationProvider = require("./notification-provider");
 const axios = require("axios");
 const Slack = require("./slack");
 const { setting } = require("../util-server");
-const { getMonitorRelativeURL, UP, DOWN } = require("../../src/util");
+const { getMonitorRelativeURL, DOWN } = require("../../src/util");
 
 class RocketChat extends NotificationProvider {
 

server/notification-providers/serverchan.js

@@ -0,0 +1,42 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const { DOWN, UP } = require("../../src/util");
+
+class ServerChan extends NotificationProvider {
+
+    name = "ServerChan";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+        try {
+            await axios.post(`https://sctapi.ftqq.com/${notification.serverChanSendKey}.send`, {
+                "title": this.checkStatus(heartbeatJSON, monitorJSON),
+                "desp": msg,
+            });
+
+            return okMsg;
+
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+
+    /**
+     * Get the formatted title for message
+     * @param {?Object} monitorJSON Monitor details (For Up/Down only)
+     * @param {?Object} heartbeatJSON Heartbeat details (For Up/Down only)
+     * @returns {string} Formatted title
+     */
+    checkStatus(heartbeatJSON, monitorJSON) {
+        let title = "UptimeKuma Message";
+        if (heartbeatJSON != null && heartbeatJSON["status"] === UP) {
+            title = "UptimeKuma Monitor Up " + monitorJSON["name"];
+        }
+        if (heartbeatJSON != null && heartbeatJSON["status"] === DOWN) {
+            title = "UptimeKuma Monitor Down " + monitorJSON["name"];
+        }
+        return title;
+    }
+}
+
+module.exports = ServerChan;

server/notification-providers/signal.js

@@ -16,10 +16,10 @@ class Signal extends NotificationProvider {
             };
             let config = {};
 
-            await axios.post(notification.signalURL, data, config)
+            await axios.post(notification.signalURL, data, config);
             return okMsg;
         } catch (error) {
-            this.throwGeneralAxiosError(error)
+            this.throwGeneralAxiosError(error);
         }
     }
 }

server/notification-providers/slack.js

@@ -1,7 +1,7 @@
 const NotificationProvider = require("./notification-provider");
 const axios = require("axios");
 const { setSettings, setting } = require("../util-server");
-const { getMonitorRelativeURL } = require("../../src/util");
+const { getMonitorRelativeURL, UP } = require("../../src/util");
 
 class Slack extends NotificationProvider {
 
@@ -10,6 +10,7 @@ class Slack extends NotificationProvider {
     /**
      * Deprecated property notification.slackbutton
      * Set it as primary base url if this is not yet set.
+     * @param {string} url The primary base URL to use
      */
     static async deprecateURL(url) {
         let currentPrimaryBaseURL = await setting("primaryBaseURL");
@@ -41,28 +42,35 @@ class Slack extends NotificationProvider {
             const time = heartbeatJSON["time"];
             const textMsg = "Uptime Kuma Alert";
             let data = {
-                "text": monitorJSON ? textMsg + `: ${monitorJSON.name}` : textMsg,
+                "text": `${textMsg}\n${msg}`,
                 "channel": notification.slackchannel,
                 "username": notification.slackusername,
                 "icon_emoji": notification.slackiconemo,
-                "blocks": [{
-                    "type": "header",
-                    "text": {
-                        "type": "plain_text",
-                        "text": "Uptime Kuma Alert",
-                    },
-                },
-                {
-                    "type": "section",
-                    "fields": [{
-                        "type": "mrkdwn",
-                        "text": "*Message*\n" + msg,
-                    },
+                "attachments": [
                     {
-                        "type": "mrkdwn",
-                        "text": "*Time (UTC)*\n" + time,
-                    }],
-                }],
+                        "color": (heartbeatJSON["status"] === UP) ? "#2eb886" : "#e01e5a",
+                        "blocks": [
+                            {
+                                "type": "header",
+                                "text": {
+                                    "type": "plain_text",
+                                    "text": "Uptime Kuma Alert",
+                                },
+                            },
+                            {
+                                "type": "section",
+                                "fields": [{
+                                    "type": "mrkdwn",
+                                    "text": "*Message*\n" + msg,
+                                },
+                                {
+                                    "type": "mrkdwn",
+                                    "text": "*Time (UTC)*\n" + time,
+                                }],
+                            }
+                        ],
+                    }
+                ]
             };
 
             if (notification.slackbutton) {
@@ -73,17 +81,19 @@ class Slack extends NotificationProvider {
 
             // Button
             if (baseURL) {
-                data.blocks.push({
-                    "type": "actions",
-                    "elements": [{
-                        "type": "button",
-                        "text": {
-                            "type": "plain_text",
-                            "text": "Visit Uptime Kuma",
-                        },
-                        "value": "Uptime-Kuma",
-                        "url": baseURL + getMonitorRelativeURL(monitorJSON.id),
-                    }],
+                data.attachments.forEach(element => {
+                    element.blocks.push({
+                        "type": "actions",
+                        "elements": [{
+                            "type": "button",
+                            "text": {
+                                "type": "plain_text",
+                                "text": "Visit Uptime Kuma",
+                            },
+                            "value": "Uptime-Kuma",
+                            "url": baseURL + getMonitorRelativeURL(monitorJSON.id),
+                        }],
+                    });
                 });
             }
 

server/notification-providers/smseagle.js

@@ -0,0 +1,71 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+class SMSEagle extends NotificationProvider {
+
+    name = "SMSEagle";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+
+        try {
+            let config = {
+                headers: {
+                    "Content-Type": "application/json",
+                }
+            };
+
+            let postData;
+            let sendMethod;
+            let recipientType;
+
+            let encoding = (notification.smseagleEncoding) ? "1" : "0";
+            let priority = (notification.smseaglePriority) ? notification.smseaglePriority : "0";
+
+            if (notification.smseagleRecipientType === "smseagle-contact") {
+                recipientType = "contactname";
+                sendMethod = "sms.send_tocontact";
+            }
+            if (notification.smseagleRecipientType === "smseagle-group") {
+                recipientType = "groupname";
+                sendMethod = "sms.send_togroup";
+            }
+            if (notification.smseagleRecipientType === "smseagle-to") {
+                recipientType = "to";
+                sendMethod = "sms.send_sms";
+            }
+
+            let params = {
+                access_token: notification.smseagleToken,
+                [recipientType]: notification.smseagleRecipient,
+                message: msg,
+                responsetype: "extended",
+                unicode: encoding,
+                highpriority: priority
+            };
+
+            postData = {
+                method: sendMethod,
+                params: params
+            };
+
+            let resp = await axios.post(notification.smseagleUrl + "/jsonrpc/sms", postData, config);
+
+            if ((JSON.stringify(resp.data)).indexOf("message_id") === -1) {
+                let error = "";
+                if (resp.data.result && resp.data.result.error_text) {
+                    error = `SMSEagle API returned error: ${JSON.stringify(resp.data.result.error_text)}`;
+                } else {
+                    error = "SMSEagle API returned an unexpected response";
+                }
+                throw new Error(error);
+            }
+
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = SMSEagle;

server/notification-providers/smsmanager.js

@@ -0,0 +1,25 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+class SMSManager extends NotificationProvider {
+
+    name = "SMSManager";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        try {
+            let data = {
+                apikey: notification.smsmanagerApiKey,
+                endpoint: "https://http-api.smsmanager.cz/Send",
+                message: msg.replace(/[^\x00-\x7F]/g, ""),
+                to: notification.numbers,
+                messageType: notification.messageType,
+            };
+            await axios.get(`${data.endpoint}?apikey=${data.apikey}&message=${data.message}&number=${data.to}&gateway=${data.messageType}`);
+            return "SMS sent sucessfully.";
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = SMSManager;

server/notification-providers/smtp.js

@@ -1,6 +1,6 @@
 const nodemailer = require("nodemailer");
 const NotificationProvider = require("./notification-provider");
-const { DOWN, UP } = require("../../src/util");
+const { DOWN } = require("../../src/util");
 
 class SMTP extends NotificationProvider {
 
@@ -14,9 +14,21 @@ class SMTP extends NotificationProvider {
             secure: notification.smtpSecure,
             tls: {
                 rejectUnauthorized: notification.smtpIgnoreTLSError || false,
-            },
+            }
         };
 
+        // Fix #1129
+        if (notification.smtpDkimDomain) {
+            config.dkim = {
+                domainName: notification.smtpDkimDomain,
+                keySelector: notification.smtpDkimKeySelector,
+                privateKey: notification.smtpDkimPrivateKey,
+                hashAlgo: notification.smtpDkimHashAlgo,
+                headerFieldNames: notification.smtpDkimheaderFieldNames,
+                skipFields: notification.smtpDkimskipFields,
+            };
+        }
+
         // Should fix the issue in https://github.com/louislam/uptime-kuma/issues/26#issuecomment-896373904
         if (notification.smtpUsername || notification.smtpPassword) {
             config.auth = {

server/notification-providers/splunk.js

@@ -0,0 +1,113 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const { UP, DOWN, getMonitorRelativeURL } = require("../../src/util");
+const { setting } = require("../util-server");
+let successMessage = "Sent Successfully.";
+
+class Splunk extends NotificationProvider {
+    name = "Splunk";
+
+    /**
+     * @inheritdoc
+     */
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        try {
+            if (heartbeatJSON == null) {
+                const title = "Uptime Kuma Alert";
+                const monitor = {
+                    type: "ping",
+                    url: "Uptime Kuma Test Button",
+                };
+                return this.postNotification(notification, title, msg, monitor, "trigger");
+            }
+
+            if (heartbeatJSON.status === UP) {
+                const title = "Uptime Kuma Monitor ✅ Up";
+                return this.postNotification(notification, title, heartbeatJSON.msg, monitorJSON, "recovery");
+            }
+
+            if (heartbeatJSON.status === DOWN) {
+                const title = "Uptime Kuma Monitor 🔴 Down";
+                return this.postNotification(notification, title, heartbeatJSON.msg, monitorJSON, "trigger");
+            }
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+
+    /**
+     * Check if result is successful, result code should be in range 2xx
+     * @param {Object} result Axios response object
+     * @throws {Error} The status code is not in range 2xx
+     */
+    checkResult(result) {
+        if (result.status == null) {
+            throw new Error("Splunk notification failed with invalid response!");
+        }
+        if (result.status < 200 || result.status >= 300) {
+            throw new Error("Splunk notification failed with status code " + result.status);
+        }
+    }
+
+    /**
+     * Send the message
+     * @param {BeanModel} notification Message title
+     * @param {string} title Message title
+     * @param {string} body Message
+     * @param {Object} monitorInfo Monitor details (For Up/Down only)
+     * @param {?string} eventAction Action event for PagerDuty (trigger, acknowledge, resolve)
+     * @returns {string}
+     */
+    async postNotification(notification, title, body, monitorInfo, eventAction = "trigger") {
+
+        let monitorUrl;
+        if (monitorInfo.type === "port") {
+            monitorUrl = monitorInfo.hostname;
+            if (monitorInfo.port) {
+                monitorUrl += ":" + monitorInfo.port;
+            }
+        } else if (monitorInfo.hostname != null) {
+            monitorUrl = monitorInfo.hostname;
+        } else {
+            monitorUrl = monitorInfo.url;
+        }
+
+        if (eventAction === "recovery") {
+            if (notification.splunkAutoResolve === "0") {
+                return "No action required";
+            }
+            eventAction = notification.splunkAutoResolve;
+        } else {
+            eventAction = notification.splunkSeverity;
+        }
+
+        const options = {
+            method: "POST",
+            url: notification.splunkRestURL,
+            headers: { "Content-Type": "application/json" },
+            data: {
+                message_type: eventAction,
+                state_message: `[${title}] [${monitorUrl}] ${body}`,
+                entity_display_name: "Uptime Kuma Alert: " + monitorInfo.name,
+                routing_key: notification.pagerdutyIntegrationKey,
+                entity_id: "Uptime Kuma/" + monitorInfo.id,
+            }
+        };
+
+        const baseURL = await setting("primaryBaseURL");
+        if (baseURL && monitorInfo) {
+            options.client = "Uptime Kuma";
+            options.client_url = baseURL + getMonitorRelativeURL(monitorInfo.id);
+        }
+
+        let result = await axios.request(options);
+        this.checkResult(result);
+        if (result.statusText != null) {
+            return "Splunk notification succeed: " + result.statusText;
+        }
+
+        return successMessage;
+    }
+}
+
+module.exports = Splunk;

server/notification-providers/squadcast.js

@@ -0,0 +1,76 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const { DOWN } = require("../../src/util");
+
+class Squadcast extends NotificationProvider {
+
+    name = "squadcast";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+
+        try {
+
+            let config = {};
+            let data = {
+                message: msg,
+                description: "",
+                tags: {},
+                heartbeat: heartbeatJSON,
+                source: "uptime-kuma"
+            };
+
+            if (heartbeatJSON !== null) {
+                data.description = heartbeatJSON["msg"];
+                data.event_id = heartbeatJSON["monitorID"];
+
+                if (heartbeatJSON["status"] === DOWN) {
+                    data.message = `${monitorJSON["name"]} is DOWN`;
+                    data.status = "trigger";
+                } else {
+                    data.message = `${monitorJSON["name"]} is UP`;
+                    data.status = "resolve";
+                }
+
+                let address;
+                switch (monitorJSON["type"]) {
+                    case "ping":
+                        address = monitorJSON["hostname"];
+                        break;
+                    case "port":
+                    case "dns":
+                    case "steam":
+                        address = monitorJSON["hostname"];
+                        if (monitorJSON["port"]) {
+                            address += ":" + monitorJSON["port"];
+                        }
+                        break;
+                    default:
+                        address = monitorJSON["url"];
+                        break;
+                }
+
+                data.tags["AlertAddress"] = address;
+
+                monitorJSON["tags"].forEach(tag => {
+                    data.tags[tag["name"]] = {
+                        value: tag["value"]
+                    };
+                    if (tag["color"] !== null) {
+                        data.tags[tag["name"]]["color"] = tag["color"];
+                    }
+                });
+            }
+
+            await axios.post(notification.squadcastWebhookURL, data, config);
+            return okMsg;
+
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+
+    }
+
+}
+
+module.exports = Squadcast;

server/notification-providers/teams.js

@@ -5,6 +5,12 @@ const { DOWN, UP } = require("../../src/util");
 class Teams extends NotificationProvider {
     name = "teams";
 
+    /**
+     * Generate the message to send
+     * @param {const} status The status constant
+     * @param {string} monitorName Name of monitor
+     * @returns {string}
+     */
     _statusMessageFactory = (status, monitorName) => {
         if (status === DOWN) {
             return `🔴 Application [${monitorName}] went down`;
@@ -14,6 +20,11 @@ class Teams extends NotificationProvider {
         return "Notification";
     };
 
+    /**
+     * Select theme color to use based on status
+     * @param {const} status The status constant
+     * @returns {string} Selected color in hex RGB format
+     */
     _getThemeColor = (status) => {
         if (status === DOWN) {
             return "ff0000";
@@ -24,6 +35,14 @@ class Teams extends NotificationProvider {
         return "008cff";
     };
 
+    /**
+     * Generate payload for notification
+     * @param {const} status The status of the monitor
+     * @param {string} monitorMessage Message to send
+     * @param {string} monitorName Name of monitor affected
+     * @param {string} monitorUrl URL of monitor affected
+     * @returns {Object}
+     */
     _notificationPayloadFactory = ({
         status,
         monitorMessage,
@@ -44,7 +63,7 @@ class Teams extends NotificationProvider {
             });
         }
 
-        if (monitorUrl) {
+        if (monitorUrl && monitorUrl !== "https://") {
             facts.push({
                 name: "URL",
                 value: monitorUrl,
@@ -74,10 +93,21 @@ class Teams extends NotificationProvider {
         };
     };
 
+    /**
+     * Send the notification
+     * @param {string} webhookUrl URL to send the request to
+     * @param {Object} payload Payload generated by _notificationPayloadFactory
+     */
     _sendNotification = async (webhookUrl, payload) => {
         await axios.post(webhookUrl, payload);
     };
 
+    /**
+     * Send a general notification
+     * @param {string} webhookUrl URL to send request to
+     * @param {string} msg Message to send
+     * @returns {Promise<void>}
+     */
     _handleGeneralNotification = (webhookUrl, msg) => {
         const payload = this._notificationPayloadFactory({
             monitorMessage: msg
@@ -97,13 +127,17 @@ class Teams extends NotificationProvider {
 
             let url;
 
-            if (monitorJSON["type"] === "port") {
-                url = monitorJSON["hostname"];
-                if (monitorJSON["port"]) {
-                    url += ":" + monitorJSON["port"];
-                }
-            } else {
-                url = monitorJSON["url"];
+            switch (monitorJSON["type"]) {
+                case "http":
+                case "keywork":
+                    url = monitorJSON["url"];
+                    break;
+                case "docker":
+                    url = monitorJSON["docker_host"];
+                    break;
+                default:
+                    url = monitorJSON["hostname"];
+                    break;
             }
 
             const payload = this._notificationPayloadFactory({

server/notification-providers/techulus-push.js

@@ -0,0 +1,23 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+class TechulusPush extends NotificationProvider {
+
+    name = "PushByTechulus";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+
+        try {
+            await axios.post(`https://push.techulus.com/api/v1/notify/${notification.pushAPIKey}`, {
+                "title": "Uptime-Kuma",
+                "body": msg,
+            });
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = TechulusPush;

server/notification-providers/telegram.js

@@ -9,17 +9,24 @@ class Telegram extends NotificationProvider {
         let okMsg = "Sent Successfully.";
 
         try {
+            let params = {
+                chat_id: notification.telegramChatID,
+                text: msg,
+                disable_notification: notification.telegramSendSilently ?? false,
+                protect_content: notification.telegramProtectContent ?? false,
+            };
+            if (notification.telegramMessageThreadID) {
+                params.message_thread_id = notification.telegramMessageThreadID;
+            }
+
             await axios.get(`https://api.telegram.org/bot${notification.telegramBotToken}/sendMessage`, {
-                params: {
-                    chat_id: notification.telegramChatID,
-                    text: msg,
-                },
-            })
+                params: params,
+            });
             return okMsg;
 
         } catch (error) {
-            let msg = (error.response.data.description) ? error.response.data.description : "Error without description"
-            throw new Error(msg)
+            let msg = (error.response.data.description) ? error.response.data.description : "Error without description";
+            throw new Error(msg);
         }
     }
 }

server/notification-providers/webhook.js

@@ -16,25 +16,34 @@ class Webhook extends NotificationProvider {
                 msg,
             };
             let finalData;
-            let config = {};
+            let config = {
+                headers: {}
+            };
 
             if (notification.webhookContentType === "form-data") {
                 finalData = new FormData();
                 finalData.append("data", JSON.stringify(data));
-
-                config = {
-                    headers: finalData.getHeaders(),
-                }
-
+                config.headers = finalData.getHeaders();
             } else {
                 finalData = data;
             }
 
-            await axios.post(notification.webhookURL, finalData, config)
+            if (notification.webhookAdditionalHeaders) {
+                try {
+                    config.headers = {
+                        ...config.headers,
+                        ...JSON.parse(notification.webhookAdditionalHeaders)
+                    };
+                } catch (err) {
+                    throw "Additional Headers is not a valid JSON";
+                }
+            }
+
+            await axios.post(notification.webhookURL, finalData, config);
             return okMsg;
 
         } catch (error) {
-            this.throwGeneralAxiosError(error)
+            this.throwGeneralAxiosError(error);
         }
 
     }

server/notification-providers/wecom.js

@@ -0,0 +1,53 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const { DOWN, UP } = require("../../src/util");
+
+class WeCom extends NotificationProvider {
+
+    name = "WeCom";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+
+        try {
+            let WeComUrl = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=" + notification.weComBotKey;
+            let config = {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            };
+            let body = this.composeMessage(heartbeatJSON, msg);
+            await axios.post(WeComUrl, body, config);
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+
+    /**
+     * Generate the message to send
+     * @param {Object} heartbeatJSON Heartbeat details (For Up/Down only)
+     * @param {string} msg General message
+     * @returns {Object}
+     */
+    composeMessage(heartbeatJSON, msg) {
+        let title;
+        if (msg != null && heartbeatJSON != null && heartbeatJSON["status"] === UP) {
+            title = "UptimeKuma Monitor Up";
+        }
+        if (msg != null && heartbeatJSON != null && heartbeatJSON["status"] === DOWN) {
+            title = "UptimeKuma Monitor Down";
+        }
+        if (msg != null) {
+            title = "UptimeKuma Message";
+        }
+        return {
+            msgtype: "text",
+            text: {
+                content: title + msg
+            }
+        };
+    }
+}
+
+module.exports = WeCom;

server/notification-providers/zoho-cliq.js

@@ -0,0 +1,116 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+const { DOWN, UP } = require("../../src/util");
+
+class ZohoCliq extends NotificationProvider {
+
+    name = "ZohoCliq";
+
+    /**
+     * Generate the message to send
+     * @param {const} status The status constant
+     * @param {string} monitorName Name of monitor
+     * @returns {string}
+     */
+    _statusMessageFactory = (status, monitorName) => {
+        if (status === DOWN) {
+            return `🔴 Application [${monitorName}] went down\n`;
+        } else if (status === UP) {
+            return `✅ Application [${monitorName}] is back online\n`;
+        }
+        return "Notification\n";
+    };
+
+    /**
+     * Send the notification
+     * @param {string} webhookUrl URL to send the request to
+     * @param {Array} payload Payload generated by _notificationPayloadFactory
+     */
+    _sendNotification = async (webhookUrl, payload) => {
+        await axios.post(webhookUrl, { text: payload.join("\n") });
+    };
+
+    /**
+     * Generate payload for notification
+     * @param {const} status The status of the monitor
+     * @param {string} monitorMessage Message to send
+     * @param {string} monitorName Name of monitor affected
+     * @param {string} monitorUrl URL of monitor affected
+     * @returns {Array}
+     */
+    _notificationPayloadFactory = ({
+        status,
+        monitorMessage,
+        monitorName,
+        monitorUrl,
+    }) => {
+        const payload = [];
+        payload.push("### Uptime Kuma\n");
+        payload.push(this._statusMessageFactory(status, monitorName));
+        payload.push(`*Description:* ${monitorMessage}`);
+
+        if (monitorName) {
+            payload.push(`*Monitor:* ${monitorName}`);
+        }
+
+        if (monitorUrl && monitorUrl !== "https://") {
+            payload.push(`*URL:* [${monitorUrl}](${monitorUrl})`);
+        }
+
+        return payload;
+    };
+
+    /**
+     * Send a general notification
+     * @param {string} webhookUrl URL to send request to
+     * @param {string} msg Message to send
+     * @returns {Promise<void>}
+     */
+    _handleGeneralNotification = (webhookUrl, msg) => {
+        const payload = this._notificationPayloadFactory({
+            monitorMessage: msg
+        });
+
+        return this._sendNotification(webhookUrl, payload);
+    };
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+
+        try {
+            if (heartbeatJSON == null) {
+                await this._handleGeneralNotification(notification.webhookUrl, msg);
+                return okMsg;
+            }
+
+            let url;
+            switch (monitorJSON["type"]) {
+                case "http":
+                case "keywork":
+                    url = monitorJSON["url"];
+                    break;
+                case "docker":
+                    url = monitorJSON["docker_host"];
+                    break;
+                default:
+                    url = monitorJSON["hostname"];
+                    break;
+            }
+
+            const payload = this._notificationPayloadFactory({
+                monitorMessage: heartbeatJSON.msg,
+                monitorName: monitorJSON.name,
+                monitorUrl: url,
+                status: heartbeatJSON.status
+            });
+
+            await this._sendNotification(notification.webhookUrl, payload);
+            return okMsg;
+
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = ZohoCliq;

server/notification.js

@@ -1,67 +1,111 @@
 const { R } = require("redbean-node");
+const { log } = require("../src/util");
+const Alerta = require("./notification-providers/alerta");
+const AlertNow = require("./notification-providers/alertnow");
+const AliyunSms = require("./notification-providers/aliyun-sms");
 const Apprise = require("./notification-providers/apprise");
-const Discord = require("./notification-providers/discord");
-const Gotify = require("./notification-providers/gotify");
-const Line = require("./notification-providers/line");
-const LunaSea = require("./notification-providers/lunasea");
-const Mattermost = require("./notification-providers/mattermost");
-const Matrix = require("./notification-providers/matrix");
-const Octopush = require("./notification-providers/octopush");
-const PromoSMS = require("./notification-providers/promosms");
+const Bark = require("./notification-providers/bark");
 const ClickSendSMS = require("./notification-providers/clicksendsms");
+const DingDing = require("./notification-providers/dingding");
+const Discord = require("./notification-providers/discord");
+const Feishu = require("./notification-providers/feishu");
+const FreeMobile = require("./notification-providers/freemobile");
+const GoogleChat = require("./notification-providers/google-chat");
+const Gorush = require("./notification-providers/gorush");
+const Gotify = require("./notification-providers/gotify");
+const HomeAssistant = require("./notification-providers/home-assistant");
+const Kook = require("./notification-providers/kook");
+const Line = require("./notification-providers/line");
+const LineNotify = require("./notification-providers/linenotify");
+const LunaSea = require("./notification-providers/lunasea");
+const Matrix = require("./notification-providers/matrix");
+const Mattermost = require("./notification-providers/mattermost");
+const Ntfy = require("./notification-providers/ntfy");
+const Octopush = require("./notification-providers/octopush");
+const OneBot = require("./notification-providers/onebot");
+const PagerDuty = require("./notification-providers/pagerduty");
+const PromoSMS = require("./notification-providers/promosms");
 const Pushbullet = require("./notification-providers/pushbullet");
+const PushDeer = require("./notification-providers/pushdeer");
 const Pushover = require("./notification-providers/pushover");
 const Pushy = require("./notification-providers/pushy");
 const RocketChat = require("./notification-providers/rocket-chat");
+const SerwerSMS = require("./notification-providers/serwersms");
 const Signal = require("./notification-providers/signal");
 const Slack = require("./notification-providers/slack");
+const SMSEagle = require("./notification-providers/smseagle");
 const SMTP = require("./notification-providers/smtp");
-const Teams = require("./notification-providers/teams");
-const Telegram = require("./notification-providers/telegram");
-const Webhook = require("./notification-providers/webhook");
-const Feishu = require("./notification-providers/feishu");
-const AliyunSms = require("./notification-providers/aliyun-sms");
-const DingDing = require("./notification-providers/dingding");
-const Bark = require("./notification-providers/bark");
-const SerwerSMS = require("./notification-providers/serwersms");
+const Squadcast = require("./notification-providers/squadcast");
 const Stackfield = require("./notification-providers/stackfield");
+const Teams = require("./notification-providers/teams");
+const TechulusPush = require("./notification-providers/techulus-push");
+const Telegram = require("./notification-providers/telegram");
+const Splunk = require("./notification-providers/splunk");
+const Webhook = require("./notification-providers/webhook");
+const WeCom = require("./notification-providers/wecom");
+const GoAlert = require("./notification-providers/goalert");
+const SMSManager = require("./notification-providers/smsmanager");
+const ServerChan = require("./notification-providers/serverchan");
+const ZohoCliq = require("./notification-providers/zoho-cliq");
 
 class Notification {
 
     providerList = {};
 
+    /** Initialize the notification providers */
     static init() {
-        console.log("Prepare Notification Providers");
+        log.info("notification", "Prepare Notification Providers");
 
         this.providerList = {};
 
         const list = [
-            new Apprise(),
+            new Alerta(),
+            new AlertNow(),
             new AliyunSms(),
+            new Apprise(),
+            new Bark(),
+            new ClickSendSMS(),
             new DingDing(),
             new Discord(),
-            new Teams(),
-            new Gotify(),
-            new Line(),
-            new LunaSea(),
             new Feishu(),
-            new Mattermost(),
+            new FreeMobile(),
+            new GoogleChat(),
+            new Gorush(),
+            new Gotify(),
+            new HomeAssistant(),
+            new Kook(),
+            new Line(),
+            new LineNotify(),
+            new LunaSea(),
             new Matrix(),
+            new Mattermost(),
+            new Ntfy(),
             new Octopush(),
+            new OneBot(),
+            new PagerDuty(),
             new PromoSMS(),
-            new ClickSendSMS(),
             new Pushbullet(),
+            new PushDeer(),
             new Pushover(),
             new Pushy(),
             new RocketChat(),
-            new Signal(),
-            new Slack(),
-            new SMTP(),
-            new Telegram(),
-            new Webhook(),
-            new Bark(),
+            new ServerChan(),
             new SerwerSMS(),
+            new Signal(),
+            new SMSManager(),
+            new Slack(),
+            new SMSEagle(),
+            new SMTP(),
+            new Squadcast(),
             new Stackfield(),
+            new Teams(),
+            new TechulusPush(),
+            new Telegram(),
+            new Splunk(),
+            new Webhook(),
+            new WeCom(),
+            new GoAlert(),
+            new ZohoCliq()
         ];
 
         for (let item of list) {
@@ -77,13 +121,13 @@ class Notification {
     }
 
     /**
-     *
-     * @param notification : BeanModel
-     * @param msg : string General Message
-     * @param monitorJSON : object Monitor details (For Up/Down only)
-     * @param heartbeatJSON : object Heartbeat details (For Up/Down only)
+     * Send a notification
+     * @param {BeanModel} notification
+     * @param {string} msg General Message
+     * @param {Object} monitorJSON Monitor details (For Up/Down only)
+     * @param {Object} heartbeatJSON Heartbeat details (For Up/Down only)
      * @returns {Promise<string>} Successful msg
-     * Throw Error with fail msg
+     * @throws Error with fail msg
      */
     static async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
         if (this.providerList[notification.type]) {
@@ -93,28 +137,35 @@ class Notification {
         }
     }
 
+    /**
+     * Save a notification
+     * @param {Object} notification Notification to save
+     * @param {?number} notificationID ID of notification to update
+     * @param {number} userID ID of user who adds notification
+     * @returns {Promise<Bean>}
+     */
     static async save(notification, notificationID, userID) {
-        let bean
+        let bean;
 
         if (notificationID) {
             bean = await R.findOne("notification", " id = ? AND user_id = ? ", [
                 notificationID,
                 userID,
-            ])
+            ]);
 
             if (! bean) {
-                throw new Error("notification not found")
+                throw new Error("notification not found");
             }
 
         } else {
-            bean = R.dispense("notification")
+            bean = R.dispense("notification");
         }
 
         bean.name = notification.name;
         bean.user_id = userID;
         bean.config = JSON.stringify(notification);
         bean.is_default = notification.isDefault || false;
-        await R.store(bean)
+        await R.store(bean);
 
         if (notification.applyExisting) {
             await applyNotificationEveryMonitor(bean.id, userID);
@@ -123,19 +174,29 @@ class Notification {
         return bean;
     }
 
+    /**
+     * Delete a notification
+     * @param {number} notificationID ID of notification to delete
+     * @param {number} userID ID of user who created notification
+     * @returns {Promise<void>}
+     */
     static async delete(notificationID, userID) {
         let bean = await R.findOne("notification", " id = ? AND user_id = ? ", [
             notificationID,
             userID,
-        ])
+        ]);
 
         if (! bean) {
-            throw new Error("notification not found")
+            throw new Error("notification not found");
         }
 
-        await R.trash(bean)
+        await R.trash(bean);
     }
 
+    /**
+     * Check if apprise exists
+     * @returns {boolean} Does the command apprise exist?
+     */
     static checkApprise() {
         let commandExistsSync = require("command-exists").sync;
         let exists = commandExistsSync("apprise");
@@ -144,6 +205,12 @@ class Notification {
 
 }
 
+/**
+ * Apply the notification to every monitor
+ * @param {number} notificationID ID of notification to apply
+ * @param {number} userID ID of user who created notification
+ * @returns {Promise<void>}
+ */
 async function applyNotificationEveryMonitor(notificationID, userID) {
     let monitors = await R.getAll("SELECT id FROM monitor WHERE user_id = ?", [
         userID
@@ -153,17 +220,17 @@ async function applyNotificationEveryMonitor(notificationID, userID) {
         let checkNotification = await R.findOne("monitor_notification", " monitor_id = ? AND notification_id = ? ", [
             monitors[i].id,
             notificationID,
-        ])
+        ]);
 
         if (! checkNotification) {
             let relation = R.dispense("monitor_notification");
             relation.monitor_id = monitors[i].id;
             relation.notification_id = notificationID;
-            await R.store(relation)
+            await R.store(relation);
         }
     }
 }
 
 module.exports = {
     Notification,
-}
+};

server/password-hash.js

@@ -2,22 +2,42 @@ const passwordHashOld = require("password-hash");
 const bcrypt = require("bcryptjs");
 const saltRounds = 10;
 
+/**
+ * Hash a password
+ * @param {string} password
+ * @returns {string}
+ */
 exports.generate = function (password) {
     return bcrypt.hashSync(password, saltRounds);
-}
+};
 
+/**
+ * Verify a password against a hash
+ * @param {string} password
+ * @param {string} hash
+ * @returns {boolean} Does the password match the hash?
+ */
 exports.verify = function (password, hash) {
     if (isSHA1(hash)) {
-        return passwordHashOld.verify(password, hash)
+        return passwordHashOld.verify(password, hash);
     }
 
     return bcrypt.compareSync(password, hash);
-}
+};
 
+/**
+ * Is the hash a SHA1 hash
+ * @param {string} hash
+ * @returns {boolean}
+ */
 function isSHA1(hash) {
-    return (typeof hash === "string" && hash.startsWith("sha1"))
+    return (typeof hash === "string" && hash.startsWith("sha1"));
 }
 
+/**
+ * Does the hash need to be rehashed?
+ * @returns {boolean}
+ */
 exports.needRehash = function (hash) {
     return isSHA1(hash);
-}
+};

server/ping-lite.js

@@ -1,178 +0,0 @@
-// https://github.com/ben-bradley/ping-lite/blob/master/ping-lite.js
-// Fixed on Windows
-const net = require("net");
-const spawn = require("child_process").spawn;
-const events = require("events");
-const fs = require("fs");
-const util = require("./util-server");
-
-module.exports = Ping;
-
-function Ping(host, options) {
-    if (!host) {
-        throw new Error("You must specify a host to ping!");
-    }
-
-    this._host = host;
-    this._options = options = (options || {});
-
-    events.EventEmitter.call(this);
-
-    const timeout = 10;
-
-    if (util.WIN) {
-        this._bin = "c:/windows/system32/ping.exe";
-        this._args = (options.args) ? options.args : [ "-n", "1", "-w", timeout * 1000, host ];
-        this._regmatch = /[><=]([0-9.]+?)ms/;
-
-    } else if (util.LIN) {
-        this._bin = "/bin/ping";
-
-        const defaultArgs = [ "-n", "-w", timeout, "-c", "1", host ];
-
-        if (net.isIPv6(host) || options.ipv6) {
-            defaultArgs.unshift("-6");
-        }
-
-        this._args = (options.args) ? options.args : defaultArgs;
-        this._regmatch = /=([0-9.]+?) ms/;
-
-    } else if (util.MAC) {
-
-        if (net.isIPv6(host) || options.ipv6) {
-            this._bin = "/sbin/ping6";
-        } else {
-            this._bin = "/sbin/ping";
-        }
-
-        this._args = (options.args) ? options.args : [ "-n", "-t", timeout, "-c", "1", host ];
-        this._regmatch = /=([0-9.]+?) ms/;
-
-    } else if (util.FBSD) {
-        this._bin = "/sbin/ping";
-
-        const defaultArgs = [ "-n", "-t", timeout, "-c", "1", host ];
-
-        if (net.isIPv6(host) || options.ipv6) {
-            defaultArgs.unshift("-6");
-        }
-
-        this._args = (options.args) ? options.args : defaultArgs;
-        this._regmatch = /=([0-9.]+?) ms/;
-
-    } else {
-        throw new Error("Could not detect your ping binary.");
-    }
-
-    if (!fs.existsSync(this._bin)) {
-        throw new Error("Could not detect " + this._bin + " on your system");
-    }
-
-    this._i = 0;
-
-    return this;
-}
-
-Ping.prototype.__proto__ = events.EventEmitter.prototype;
-
-// SEND A PING
-// ===========
-Ping.prototype.send = function (callback) {
-    let self = this;
-    callback = callback || function (err, ms) {
-        if (err) {
-            return self.emit("error", err);
-        }
-        return self.emit("result", ms);
-    };
-
-    let _ended;
-    let _exited;
-    let _errored;
-
-    this._ping = spawn(this._bin, this._args); // spawn the binary
-
-    this._ping.on("error", function (err) { // handle binary errors
-        _errored = true;
-        callback(err);
-    });
-
-    this._ping.stdout.on("data", function (data) { // log stdout
-        if (util.WIN) {
-            data = convertOutput(data);
-        }
-        this._stdout = (this._stdout || "") + data;
-    });
-
-    this._ping.stdout.on("end", function () {
-        _ended = true;
-        if (_exited && !_errored) {
-            onEnd.call(self._ping);
-        }
-    });
-
-    this._ping.stderr.on("data", function (data) { // log stderr
-        if (util.WIN) {
-            data = convertOutput(data);
-        }
-        this._stderr = (this._stderr || "") + data;
-    });
-
-    this._ping.on("exit", function (code) { // handle complete
-        _exited = true;
-        if (_ended && !_errored) {
-            onEnd.call(self._ping);
-        }
-    });
-
-    function onEnd() {
-        let stdout = this.stdout._stdout;
-        let stderr = this.stderr._stderr;
-        let ms;
-
-        if (stderr) {
-            return callback(new Error(stderr));
-        }
-
-        if (!stdout) {
-            return callback(new Error("No stdout detected"));
-        }
-
-        ms = stdout.match(self._regmatch); // parse out the ##ms response
-        ms = (ms && ms[1]) ? Number(ms[1]) : ms;
-
-        callback(null, ms, stdout);
-    }
-};
-
-// CALL Ping#send(callback) ON A TIMER
-// ===================================
-Ping.prototype.start = function (callback) {
-    let self = this;
-    this._i = setInterval(function () {
-        self.send(callback);
-    }, (self._options.interval || 5000));
-    self.send(callback);
-};
-
-// STOP SENDING PINGS
-// ==================
-Ping.prototype.stop = function () {
-    clearInterval(this._i);
-};
-
-/**
- * Try to convert to UTF-8 for Windows, as the ping's output on Windows is not UTF-8 and could be in other languages
- * Thank @pemassi
- * https://github.com/louislam/uptime-kuma/issues/570#issuecomment-941984094
- * @param data
- * @returns {string}
- */
-function convertOutput(data) {
-    if (util.WIN) {
-        if (data) {
-            return util.convertToUTF8(data);
-        }
-    }
-    return data;
-}

server/plugin.js

@@ -0,0 +1,13 @@
+class Plugin {
+    async load() {
+
+    }
+
+    async unload() {
+
+    }
+}
+
+module.exports = {
+    Plugin,
+};

server/plugins-manager.js

@@ -0,0 +1,256 @@
+const fs = require("fs");
+const { log } = require("../src/util");
+const path = require("path");
+const axios = require("axios");
+const { Git } = require("./git");
+const childProcess = require("child_process");
+
+class PluginsManager {
+
+    static disable = false;
+
+    /**
+     * Plugin List
+     * @type {PluginWrapper[]}
+     */
+    pluginList = [];
+
+    /**
+     * Plugins Dir
+     */
+    pluginsDir;
+
+    server;
+
+    /**
+     *
+     * @param {UptimeKumaServer} server
+     */
+    constructor(server) {
+        this.server = server;
+
+        if (!PluginsManager.disable) {
+            this.pluginsDir = "./data/plugins/";
+
+            if (! fs.existsSync(this.pluginsDir)) {
+                fs.mkdirSync(this.pluginsDir, { recursive: true });
+            }
+
+            log.debug("plugin", "Scanning plugin directory");
+            let list = fs.readdirSync(this.pluginsDir);
+
+            this.pluginList = [];
+            for (let item of list) {
+                this.loadPlugin(item);
+            }
+
+        } else {
+            log.warn("PLUGIN", "Skip scanning plugin directory");
+        }
+
+    }
+
+    /**
+     * Install a Plugin
+     */
+    async loadPlugin(name) {
+        log.info("plugin", "Load " + name);
+        let plugin = new PluginWrapper(this.server, this.pluginsDir + name);
+
+        try {
+            await plugin.load();
+            this.pluginList.push(plugin);
+        } catch (e) {
+            log.error("plugin", "Failed to load plugin: " + this.pluginsDir + name);
+            log.error("plugin", "Reason: " + e.message);
+        }
+    }
+
+    /**
+     * Download a Plugin
+     * @param {string} repoURL Git repo url
+     * @param {string} name Directory name, also known as plugin unique name
+     */
+    downloadPlugin(repoURL, name) {
+        if (fs.existsSync(this.pluginsDir + name)) {
+            log.info("plugin", "Plugin folder already exists? Removing...");
+            fs.rmSync(this.pluginsDir + name, {
+                recursive: true
+            });
+        }
+        log.info("plugin", "Installing plugin: " + name + " " + repoURL);
+        let result = Git.clone(repoURL, this.pluginsDir, name);
+        log.info("plugin", "Install result: " + result);
+    }
+
+    /**
+     * Remove a plugin
+     * @param {string} name
+     */
+    async removePlugin(name) {
+        log.info("plugin", "Removing plugin: " + name);
+        for (let plugin of this.pluginList) {
+            if (plugin.info.name === name) {
+                await plugin.unload();
+
+                // Delete the plugin directory
+                fs.rmSync(this.pluginsDir + name, {
+                    recursive: true
+                });
+
+                this.pluginList.splice(this.pluginList.indexOf(plugin), 1);
+                return;
+            }
+        }
+        log.warn("plugin", "Plugin not found: " + name);
+        throw new Error("Plugin not found: " + name);
+    }
+
+    /**
+     * TODO: Update a plugin
+     * Only available for plugins which were downloaded from the official list
+     * @param pluginID
+     */
+    updatePlugin(pluginID) {
+
+    }
+
+    /**
+     * Get the plugin list from server + local installed plugin list
+     * Item will be merged if the `name` is the same.
+     * @returns {Promise<[]>}
+     */
+    async fetchPluginList() {
+        let remotePluginList;
+        try {
+            const res = await axios.get("https://uptime.kuma.pet/c/plugins.json");
+            remotePluginList = res.data.pluginList;
+        } catch (e) {
+            log.error("plugin", "Failed to fetch plugin list: " + e.message);
+            remotePluginList = [];
+        }
+
+        for (let plugin of this.pluginList) {
+            let find = false;
+            // Try to merge
+            for (let remotePlugin of remotePluginList) {
+                if (remotePlugin.name === plugin.info.name) {
+                    find = true;
+                    remotePlugin.installed = true;
+                    remotePlugin.name = plugin.info.name;
+                    remotePlugin.fullName = plugin.info.fullName;
+                    remotePlugin.description = plugin.info.description;
+                    remotePlugin.version = plugin.info.version;
+                    break;
+                }
+            }
+
+            // Local plugin
+            if (!find) {
+                plugin.info.local = true;
+                remotePluginList.push(plugin.info);
+            }
+        }
+
+        // Sort Installed first, then sort by name
+        return remotePluginList.sort((a, b) => {
+            if (a.installed === b.installed) {
+                if (a.fullName < b.fullName) {
+                    return -1;
+                }
+                if (a.fullName > b.fullName) {
+                    return 1;
+                }
+                return 0;
+            } else if (a.installed) {
+                return -1;
+            } else {
+                return 1;
+            }
+        });
+    }
+}
+
+class PluginWrapper {
+
+    server = undefined;
+    pluginDir = undefined;
+
+    /**
+     * Must be an `new-able` class.
+     * @type {function}
+     */
+    pluginClass = undefined;
+
+    /**
+     *
+     * @type {Plugin}
+     */
+    object = undefined;
+    info = {};
+
+    /**
+     *
+     * @param {UptimeKumaServer} server
+     * @param {string} pluginDir
+     */
+    constructor(server, pluginDir) {
+        this.server = server;
+        this.pluginDir = pluginDir;
+    }
+
+    async load() {
+        let indexFile = this.pluginDir + "/index.js";
+        let packageJSON = this.pluginDir + "/package.json";
+
+        log.info("plugin", "Installing dependencies");
+
+        if (fs.existsSync(indexFile)) {
+            // Install dependencies
+            let result = childProcess.spawnSync("npm", [ "install" ], {
+                cwd: this.pluginDir,
+                env: {
+                    ...process.env,
+                    PLAYWRIGHT_BROWSERS_PATH: "../../browsers",    // Special handling for read-browser-monitor
+                }
+            });
+
+            if (result.stdout) {
+                log.info("plugin", "Install dependencies result: " + result.stdout.toString("utf-8"));
+            } else {
+                log.warn("plugin", "Install dependencies result: no output");
+            }
+
+            this.pluginClass = require(path.join(process.cwd(), indexFile));
+
+            let pluginClassType = typeof this.pluginClass;
+
+            if (pluginClassType === "function") {
+                this.object = new this.pluginClass(this.server);
+                await this.object.load();
+            } else {
+                throw new Error("Invalid plugin, it does not export a class");
+            }
+
+            if (fs.existsSync(packageJSON)) {
+                this.info = require(path.join(process.cwd(), packageJSON));
+            } else {
+                this.info.fullName = this.pluginDir;
+                this.info.name = "[unknown]";
+                this.info.version = "[unknown-version]";
+            }
+
+            this.info.installed = true;
+            log.info("plugin", `${this.info.fullName} v${this.info.version} loaded`);
+        }
+    }
+
+    async unload() {
+        await this.object.unload();
+    }
+}
+
+module.exports = {
+    PluginsManager,
+    PluginWrapper
+};

server/prometheus.js

@@ -1,4 +1,5 @@
 const PrometheusClient = require("prom-client");
+const { log } = require("../src/util");
 
 const commonLabels = [
     "monitor_name",
@@ -8,32 +9,35 @@ const commonLabels = [
     "monitor_port",
 ];
 
-const monitor_cert_days_remaining = new PrometheusClient.Gauge({
+const monitorCertDaysRemaining = new PrometheusClient.Gauge({
     name: "monitor_cert_days_remaining",
     help: "The number of days remaining until the certificate expires",
     labelNames: commonLabels
 });
 
-const monitor_cert_is_valid = new PrometheusClient.Gauge({
+const monitorCertIsValid = new PrometheusClient.Gauge({
     name: "monitor_cert_is_valid",
     help: "Is the certificate still valid? (1 = Yes, 0= No)",
     labelNames: commonLabels
 });
-const monitor_response_time = new PrometheusClient.Gauge({
+const monitorResponseTime = new PrometheusClient.Gauge({
     name: "monitor_response_time",
     help: "Monitor Response Time (ms)",
     labelNames: commonLabels
 });
 
-const monitor_status = new PrometheusClient.Gauge({
+const monitorStatus = new PrometheusClient.Gauge({
     name: "monitor_status",
     help: "Monitor Status (1 = UP, 0= DOWN)",
     labelNames: commonLabels
 });
 
 class Prometheus {
-    monitorLabelValues = {}
+    monitorLabelValues = {};
 
+    /**
+     * @param {Object} monitor Monitor object to monitor
+     */
     constructor(monitor) {
         this.monitorLabelValues = {
             monitor_name: monitor.name,
@@ -44,46 +48,68 @@ class Prometheus {
         };
     }
 
+    /**
+     * Update the metrics page
+     * @param {Object} heartbeat Heartbeat details
+     * @param {Object} tlsInfo TLS details
+     */
     update(heartbeat, tlsInfo) {
 
         if (typeof tlsInfo !== "undefined") {
             try {
-                let is_valid = 0;
-                if (tlsInfo.valid == true) {
-                    is_valid = 1;
+                let isValid;
+                if (tlsInfo.valid === true) {
+                    isValid = 1;
                 } else {
-                    is_valid = 0;
+                    isValid = 0;
                 }
-                monitor_cert_is_valid.set(this.monitorLabelValues, is_valid);
+                monitorCertIsValid.set(this.monitorLabelValues, isValid);
             } catch (e) {
-                console.error(e);
+                log.error("prometheus", "Caught error");
+                log.error("prometheus", e);
             }
 
             try {
-                monitor_cert_days_remaining.set(this.monitorLabelValues, tlsInfo.certInfo.daysRemaining);
+                if (tlsInfo.certInfo != null) {
+                    monitorCertDaysRemaining.set(this.monitorLabelValues, tlsInfo.certInfo.daysRemaining);
+                }
             } catch (e) {
-                console.error(e);
+                log.error("prometheus", "Caught error");
+                log.error("prometheus", e);
             }
         }
 
         try {
-            monitor_status.set(this.monitorLabelValues, heartbeat.status);
+            monitorStatus.set(this.monitorLabelValues, heartbeat.status);
         } catch (e) {
-            console.error(e);
+            log.error("prometheus", "Caught error");
+            log.error("prometheus", e);
         }
 
         try {
             if (typeof heartbeat.ping === "number") {
-                monitor_response_time.set(this.monitorLabelValues, heartbeat.ping);
+                monitorResponseTime.set(this.monitorLabelValues, heartbeat.ping);
             } else {
                 // Is it good?
-                monitor_response_time.set(this.monitorLabelValues, -1);
+                monitorResponseTime.set(this.monitorLabelValues, -1);
             }
+        } catch (e) {
+            log.error("prometheus", "Caught error");
+            log.error("prometheus", e);
+        }
+    }
+
+    /** Remove monitor from prometheus */
+    remove() {
+        try {
+            monitorCertDaysRemaining.remove(this.monitorLabelValues);
+            monitorCertIsValid.remove(this.monitorLabelValues);
+            monitorResponseTime.remove(this.monitorLabelValues);
+            monitorStatus.remove(this.monitorLabelValues);
         } catch (e) {
             console.error(e);
         }
     }
-
 }
 
 module.exports = {

server/proxy.js

@@ -0,0 +1,190 @@
+const { R } = require("redbean-node");
+const HttpProxyAgent = require("http-proxy-agent");
+const HttpsProxyAgent = require("https-proxy-agent");
+const SocksProxyAgent = require("socks-proxy-agent");
+const { debug } = require("../src/util");
+const { UptimeKumaServer } = require("./uptime-kuma-server");
+
+class Proxy {
+
+    static SUPPORTED_PROXY_PROTOCOLS = [ "http", "https", "socks", "socks5", "socks5h", "socks4" ];
+
+    /**
+     * Saves and updates given proxy entity
+     *
+     * @param proxy
+     * @param proxyID
+     * @param userID
+     * @return {Promise<Bean>}
+     */
+    static async save(proxy, proxyID, userID) {
+        let bean;
+
+        if (proxyID) {
+            bean = await R.findOne("proxy", " id = ? AND user_id = ? ", [ proxyID, userID ]);
+
+            if (!bean) {
+                throw new Error("proxy not found");
+            }
+
+        } else {
+            bean = R.dispense("proxy");
+        }
+
+        // Make sure given proxy protocol is supported
+        if (!this.SUPPORTED_PROXY_PROTOCOLS.includes(proxy.protocol)) {
+            throw new Error(`
+                Unsupported proxy protocol "${proxy.protocol}.
+                Supported protocols are ${this.SUPPORTED_PROXY_PROTOCOLS.join(", ")}."`
+            );
+        }
+
+        // When proxy is default update deactivate old default proxy
+        if (proxy.default) {
+            await R.exec("UPDATE proxy SET `default` = 0 WHERE `default` = 1");
+        }
+
+        bean.user_id = userID;
+        bean.protocol = proxy.protocol;
+        bean.host = proxy.host;
+        bean.port = proxy.port;
+        bean.auth = proxy.auth;
+        bean.username = proxy.username;
+        bean.password = proxy.password;
+        bean.active = proxy.active || true;
+        bean.default = proxy.default || false;
+
+        await R.store(bean);
+
+        if (proxy.applyExisting) {
+            await applyProxyEveryMonitor(bean.id, userID);
+        }
+
+        return bean;
+    }
+
+    /**
+     * Deletes proxy with given id and removes it from monitors
+     *
+     * @param proxyID
+     * @param userID
+     * @return {Promise<void>}
+     */
+    static async delete(proxyID, userID) {
+        const bean = await R.findOne("proxy", " id = ? AND user_id = ? ", [ proxyID, userID ]);
+
+        if (!bean) {
+            throw new Error("proxy not found");
+        }
+
+        // Delete removed proxy from monitors if exists
+        await R.exec("UPDATE monitor SET proxy_id = null WHERE proxy_id = ?", [ proxyID ]);
+
+        // Delete proxy from list
+        await R.trash(bean);
+    }
+
+    /**
+     * Create HTTP and HTTPS agents related with given proxy bean object
+     *
+     * @param proxy proxy bean object
+     * @param options http and https agent options
+     * @return {{httpAgent: Agent, httpsAgent: Agent}}
+     */
+    static createAgents(proxy, options) {
+        const { httpAgentOptions, httpsAgentOptions } = options || {};
+        let agent;
+        let httpAgent;
+        let httpsAgent;
+
+        const proxyOptions = {
+            protocol: proxy.protocol,
+            host: proxy.host,
+            port: proxy.port,
+        };
+
+        if (proxy.auth) {
+            proxyOptions.auth = `${proxy.username}:${proxy.password}`;
+        }
+
+        debug(`Proxy Options: ${JSON.stringify(proxyOptions)}`);
+        debug(`HTTP Agent Options: ${JSON.stringify(httpAgentOptions)}`);
+        debug(`HTTPS Agent Options: ${JSON.stringify(httpsAgentOptions)}`);
+
+        switch (proxy.protocol) {
+            case "http":
+            case "https":
+                httpAgent = new HttpProxyAgent({
+                    ...httpAgentOptions || {},
+                    ...proxyOptions
+                });
+
+                httpsAgent = new HttpsProxyAgent({
+                    ...httpsAgentOptions || {},
+                    ...proxyOptions,
+                });
+                break;
+            case "socks":
+            case "socks5":
+            case "socks5h":
+            case "socks4":
+                agent = new SocksProxyAgent({
+                    ...httpAgentOptions,
+                    ...httpsAgentOptions,
+                    ...proxyOptions,
+                });
+
+                httpAgent = agent;
+                httpsAgent = agent;
+                break;
+
+            default: throw new Error(`Unsupported proxy protocol provided. ${proxy.protocol}`);
+        }
+
+        return {
+            httpAgent,
+            httpsAgent
+        };
+    }
+
+    /**
+     * Reload proxy settings for current monitors
+     * @returns {Promise<void>}
+     */
+    static async reloadProxy() {
+        const server = UptimeKumaServer.getInstance();
+
+        let updatedList = await R.getAssoc("SELECT id, proxy_id FROM monitor");
+
+        for (let monitorID in server.monitorList) {
+            let monitor = server.monitorList[monitorID];
+
+            if (updatedList[monitorID]) {
+                monitor.proxy_id = updatedList[monitorID].proxy_id;
+            }
+        }
+    }
+}
+
+/**
+ * Applies given proxy id to monitors
+ *
+ * @param proxyID
+ * @param userID
+ * @return {Promise<void>}
+ */
+async function applyProxyEveryMonitor(proxyID, userID) {
+    // Find all monitors with id and proxy id
+    const monitors = await R.getAll("SELECT id, proxy_id FROM monitor WHERE user_id = ?", [ userID ]);
+
+    // Update proxy id not match with given proxy id
+    for (const monitor of monitors) {
+        if (monitor.proxy_id !== proxyID) {
+            await R.exec("UPDATE monitor SET proxy_id = ? WHERE id = ?", [ proxyID, monitor.id ]);
+        }
+    }
+}
+
+module.exports = {
+    Proxy,
+};

server/rate-limiter.js

@@ -1,15 +1,30 @@
 const { RateLimiter } = require("limiter");
-const { debug } = require("../src/util");
+const { log } = require("../src/util");
 
 class KumaRateLimiter {
+    /**
+     * @param {Object} config Rate limiter configuration object
+     */
     constructor(config) {
         this.errorMessage = config.errorMessage;
         this.rateLimiter = new RateLimiter(config);
     }
 
+    /**
+     * Callback for pass
+     * @callback passCB
+     * @param {Object} err Too many requests
+     */
+
+    /**
+     * Should the request be passed through
+     * @param {passCB} callback
+     * @param {number} [num=1] Number of tokens to remove
+     * @returns {Promise<boolean>}
+     */
     async pass(callback, num = 1) {
         const remainingRequests = await this.removeTokens(num);
-        debug("Rate Limit (remainingRequests):" + remainingRequests);
+        log.info("rate-limit", "remaining requests: " + remainingRequests);
         if (remainingRequests < 0) {
             if (callback) {
                 callback({
@@ -22,6 +37,11 @@ class KumaRateLimiter {
         return true;
     }
 
+    /**
+     * Remove a given number of tokens
+     * @param {number} [num=1] Number of tokens to remove
+     * @returns {Promise<number>}
+     */
     async removeTokens(num = 1) {
         return await this.rateLimiter.removeTokens(num);
     }
@@ -34,6 +54,14 @@ const loginRateLimiter = new KumaRateLimiter({
     errorMessage: "Too frequently, try again later."
 });
 
+const twoFaRateLimiter = new KumaRateLimiter({
+    tokensPerInterval: 30,
+    interval: "minute",
+    fireImmediately: true,
+    errorMessage: "Too frequently, try again later."
+});
+
 module.exports = {
-    loginRateLimiter
+    loginRateLimiter,
+    twoFaRateLimiter,
 };

server/routers/api-router.js

@@ -1,19 +1,34 @@
 let express = require("express");
-const { allowDevAllOrigin, getSettings, setting } = require("../util-server");
+const { allowDevAllOrigin, allowAllOrigin, percentageToColor, filterAndJoin, sendHttpError } = require("../util-server");
 const { R } = require("redbean-node");
-const server = require("../server");
 const apicache = require("../modules/apicache");
 const Monitor = require("../model/monitor");
 const dayjs = require("dayjs");
-const { UP, flipStatus, debug } = require("../../src/util");
+const { UP, MAINTENANCE, DOWN, PENDING, flipStatus, log } = require("../../src/util");
+const StatusPage = require("../model/status_page");
+const { UptimeKumaServer } = require("../uptime-kuma-server");
+const { makeBadge } = require("badge-maker");
+const { badgeConstants } = require("../config");
+
 let router = express.Router();
 
 let cache = apicache.middleware;
+const server = UptimeKumaServer.getInstance();
 let io = server.io;
 
-router.get("/api/entry-page", async (_, response) => {
+router.get("/api/entry-page", async (request, response) => {
     allowDevAllOrigin(response);
-    response.json(server.entryPage);
+
+    let result = { };
+
+    if (request.hostname in StatusPage.domainMappingList) {
+        result.type = "statusPageMatchedDomain";
+        result.statusPageSlug = StatusPage.domainMappingList[request.hostname];
+    } else {
+        result.type = "entryPage";
+        result.entryPage = server.entryPage;
+    }
+    response.json(result);
 });
 
 router.get("/api/push/:pushToken", async (request, response) => {
@@ -22,6 +37,8 @@ router.get("/api/push/:pushToken", async (request, response) => {
         let pushToken = request.params.pushToken;
         let msg = request.query.msg || "OK";
         let ping = request.query.ping || null;
+        let statusString = request.query.status || "up";
+        let status = (statusString === "up") ? UP : DOWN;
 
         let monitor = await R.findOne("monitor", " push_token = ? AND active = 1 ", [
             pushToken
@@ -33,7 +50,6 @@ router.get("/api/push/:pushToken", async (request, response) => {
 
         const previousHeartbeat = await Monitor.getPreviousHeartbeat(monitor.id);
 
-        let status = UP;
         if (monitor.isUpsideDown()) {
             status = flipStatus(status);
         }
@@ -43,7 +59,7 @@ router.get("/api/push/:pushToken", async (request, response) => {
         let duration = 0;
 
         let bean = R.dispense("heartbeat");
-        bean.time = R.isoDateTime(dayjs.utc());
+        bean.time = R.isoDateTimeMillis(dayjs.utc());
 
         if (previousHeartbeat) {
             isFirstBeat = false;
@@ -51,8 +67,14 @@ router.get("/api/push/:pushToken", async (request, response) => {
             duration = dayjs(bean.time).diff(dayjs(previousHeartbeat.time), "second");
         }
 
-        debug("PreviousStatus: " + previousStatus);
-        debug("Current Status: " + status);
+        if (await Monitor.isUnderMaintenance(monitor.id)) {
+            msg = "Monitor under maintenance";
+            status = MAINTENANCE;
+        }
+
+        log.debug("router", `/api/push/ called at ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+        log.debug("router", "PreviousStatus: " + previousStatus);
+        log.debug("router", "Current Status: " + status);
 
         bean.important = Monitor.isImportantBeat(isFirstBeat, previousStatus, status);
         bean.monitor_id = monitor.id;
@@ -70,173 +92,452 @@ router.get("/api/push/:pushToken", async (request, response) => {
             ok: true,
         });
 
-        if (bean.important) {
+        if (Monitor.isImportantForNotification(isFirstBeat, previousStatus, status)) {
             await Monitor.sendNotification(isFirstBeat, monitor, bean);
         }
 
     } catch (e) {
-        response.json({
+        response.status(404).json({
             ok: false,
             msg: e.message
         });
     }
 });
 
-// Status Page Config
-router.get("/api/status-page/config", async (_request, response) => {
-    allowDevAllOrigin(response);
+router.get("/api/badge/:id/status", cache("5 minutes"), async (request, response) => {
+    allowAllOrigin(response);
 
-    let config = await getSettings("statusPage");
-
-    if (! config.statusPageTheme) {
-        config.statusPageTheme = "light";
-    }
-
-    if (! config.statusPagePublished) {
-        config.statusPagePublished = true;
-    }
-
-    if (! config.statusPageTags) {
-        config.statusPageTags = false;
-    }
-
-    if (! config.title) {
-        config.title = "Uptime Kuma";
-    }
-
-    response.json(config);
-});
-
-// Status Page - Get the current Incident
-// Can fetch only if published
-router.get("/api/status-page/incident", async (_, response) => {
-    allowDevAllOrigin(response);
+    const {
+        label,
+        upLabel = "Up",
+        downLabel = "Down",
+        pendingLabel = "Pending",
+        maintenanceLabel = "Maintenance",
+        upColor = badgeConstants.defaultUpColor,
+        downColor = badgeConstants.defaultDownColor,
+        pendingColor = badgeConstants.defaultPendingColor,
+        maintenanceColor = badgeConstants.defaultMaintenanceColor,
+        style = badgeConstants.defaultStyle,
+        value, // for demo purpose only
+    } = request.query;
 
     try {
-        await checkPublished();
+        const requestedMonitorId = parseInt(request.params.id, 10);
+        const overrideValue = value !== undefined ? parseInt(value) : undefined;
 
-        let incident = await R.findOne("incident", " pin = 1 AND active = 1");
+        let publicMonitor = await R.getRow(`
+                SELECT monitor_group.monitor_id FROM monitor_group, \`group\`
+                WHERE monitor_group.group_id = \`group\`.id
+                AND monitor_group.monitor_id = ?
+                AND public = 1
+            `,
+        [ requestedMonitorId ]
+        );
 
-        if (incident) {
-            incident = incident.toPublicJSON();
-        }
+        const badgeValues = { style };
 
-        response.json({
-            ok: true,
-            incident,
-        });
+        if (!publicMonitor) {
+            // return a "N/A" badge in naColor (grey), if monitor is not public / not available / non exsitant
 
-    } catch (error) {
-        send403(response, error.message);
-    }
-});
+            badgeValues.message = "N/A";
+            badgeValues.color = badgeConstants.naColor;
+        } else {
+            const heartbeat = await Monitor.getPreviousHeartbeat(requestedMonitorId);
+            const state = overrideValue !== undefined ? overrideValue : heartbeat.status;
 
-// Status Page - Monitor List
-// Can fetch only if published
-router.get("/api/status-page/monitor-list", cache("5 minutes"), async (_request, response) => {
-    allowDevAllOrigin(response);
-
-    try {
-        await checkPublished();
-        const publicGroupList = [];
-        const tagsVisible = (await getSettings("statusPage")).statusPageTags;
-        const list = await R.find("group", " public = 1 ORDER BY weight ");
-        for (let groupBean of list) {
-            let monitorGroup = await groupBean.toPublicJSON();
-            if (tagsVisible) {
-                monitorGroup.monitorList = await Promise.all(monitorGroup.monitorList.map(async (monitor) => {
-                    // Includes tags as an array in response, allows for tags to be displayed on public status page
-                    const tags = await R.getAll(
-                            `SELECT monitor_tag.monitor_id, monitor_tag.value, tag.name, tag.color
-                            FROM monitor_tag
-                            JOIN tag
-                            ON monitor_tag.tag_id = tag.id
-                            WHERE monitor_tag.monitor_id = ?`, [monitor.id]
-                    );
-                    return {
-                        ...monitor,
-                        tags: tags
-                    };
-                }));
+            badgeValues.label = label ?? "Status";
+            switch (state) {
+                case DOWN:
+                    badgeValues.color = downColor;
+                    badgeValues.message = downLabel;
+                    break;
+                case UP:
+                    badgeValues.color = upColor;
+                    badgeValues.message = upLabel;
+                    break;
+                case PENDING:
+                    badgeValues.color = pendingColor;
+                    badgeValues.message = pendingLabel;
+                    break;
+                case MAINTENANCE:
+                    badgeValues.color = maintenanceColor;
+                    badgeValues.message = maintenanceLabel;
+                    break;
+                default:
+                    badgeValues.color = badgeConstants.naColor;
+                    badgeValues.message = "N/A";
             }
-
-            publicGroupList.push(monitorGroup);
         }
 
-        response.json(publicGroupList);
+        // build the svg based on given values
+        const svg = makeBadge(badgeValues);
 
+        response.type("image/svg+xml");
+        response.send(svg);
     } catch (error) {
-        send403(response, error.message);
+        sendHttpError(response, error.message);
     }
 });
 
-// Status Page Polling Data
-// Can fetch only if published
-router.get("/api/status-page/heartbeat", cache("5 minutes"), async (_request, response) => {
-    allowDevAllOrigin(response);
+router.get("/api/badge/:id/uptime/:duration?", cache("5 minutes"), async (request, response) => {
+    allowAllOrigin(response);
+
+    const {
+        label,
+        labelPrefix,
+        labelSuffix = badgeConstants.defaultUptimeLabelSuffix,
+        prefix,
+        suffix = badgeConstants.defaultUptimeValueSuffix,
+        color,
+        labelColor,
+        style = badgeConstants.defaultStyle,
+        value, // for demo purpose only
+    } = request.query;
 
     try {
-        await checkPublished();
+        const requestedMonitorId = parseInt(request.params.id, 10);
+        // if no duration is given, set value to 24 (h)
+        const requestedDuration = request.params.duration !== undefined ? parseInt(request.params.duration, 10) : 24;
+        const overrideValue = value && parseFloat(value);
 
-        let heartbeatList = {};
-        let uptimeList = {};
+        let publicMonitor = await R.getRow(`
+                SELECT monitor_group.monitor_id FROM monitor_group, \`group\`
+                WHERE monitor_group.group_id = \`group\`.id
+                AND monitor_group.monitor_id = ?
+                AND public = 1
+            `,
+        [ requestedMonitorId ]
+        );
 
-        let monitorIDList = await R.getCol(`
+        const badgeValues = { style };
+
+        if (!publicMonitor) {
+            // return a "N/A" badge in naColor (grey), if monitor is not public / not available / non existent
+            badgeValues.message = "N/A";
+            badgeValues.color = badgeConstants.naColor;
+        } else {
+            const uptime = overrideValue ?? await Monitor.calcUptime(
+                requestedDuration,
+                requestedMonitorId
+            );
+
+            // limit the displayed uptime percentage to four (two, when displayed as percent) decimal digits
+            const cleanUptime = parseFloat(uptime.toPrecision(4));
+
+            // use a given, custom color or calculate one based on the uptime value
+            badgeValues.color = color ?? percentageToColor(uptime);
+            // use a given, custom labelColor or use the default badge label color (defined by badge-maker)
+            badgeValues.labelColor = labelColor ?? "";
+            // build a label string. If a custom label is given, override the default one (requestedDuration)
+            badgeValues.label = filterAndJoin([
+                labelPrefix,
+                label ?? `Uptime (${requestedDuration}${labelSuffix})`,
+            ]);
+            badgeValues.message = filterAndJoin([ prefix, `${cleanUptime * 100}`, suffix ]);
+        }
+
+        // build the SVG based on given values
+        const svg = makeBadge(badgeValues);
+
+        response.type("image/svg+xml");
+        response.send(svg);
+    } catch (error) {
+        sendHttpError(response, error.message);
+    }
+});
+
+router.get("/api/badge/:id/ping/:duration?", cache("5 minutes"), async (request, response) => {
+    allowAllOrigin(response);
+
+    const {
+        label,
+        labelPrefix,
+        labelSuffix = badgeConstants.defaultPingLabelSuffix,
+        prefix,
+        suffix = badgeConstants.defaultPingValueSuffix,
+        color = badgeConstants.defaultPingColor,
+        labelColor,
+        style = badgeConstants.defaultStyle,
+        value, // for demo purpose only
+    } = request.query;
+
+    try {
+        const requestedMonitorId = parseInt(request.params.id, 10);
+
+        // Default duration is 24 (h) if not defined in queryParam, limited to 720h (30d)
+        const requestedDuration = Math.min(request.params.duration ? parseInt(request.params.duration, 10) : 24, 720);
+        const overrideValue = value && parseFloat(value);
+
+        const publicAvgPing = parseInt(await R.getCell(`
+                SELECT AVG(ping) FROM monitor_group, \`group\`, heartbeat
+                WHERE monitor_group.group_id = \`group\`.id
+                AND heartbeat.time > DATETIME('now', ? || ' hours')
+                AND heartbeat.ping IS NOT NULL
+                AND public = 1
+                AND heartbeat.monitor_id = ?
+            `,
+        [ -requestedDuration, requestedMonitorId ]
+        ));
+
+        const badgeValues = { style };
+
+        if (!publicAvgPing) {
+            // return a "N/A" badge in naColor (grey), if monitor is not public / not available / non exsitant
+
+            badgeValues.message = "N/A";
+            badgeValues.color = badgeConstants.naColor;
+        } else {
+            const avgPing = parseInt(overrideValue ?? publicAvgPing);
+
+            badgeValues.color = color;
+            // use a given, custom labelColor or use the default badge label color (defined by badge-maker)
+            badgeValues.labelColor = labelColor ?? "";
+            // build a lable string. If a custom label is given, override the default one (requestedDuration)
+            badgeValues.label = filterAndJoin([ labelPrefix, label ?? `Avg. Ping (${requestedDuration}${labelSuffix})` ]);
+            badgeValues.message = filterAndJoin([ prefix, avgPing, suffix ]);
+        }
+
+        // build the SVG based on given values
+        const svg = makeBadge(badgeValues);
+
+        response.type("image/svg+xml");
+        response.send(svg);
+    } catch (error) {
+        sendHttpError(response, error.message);
+    }
+});
+
+router.get("/api/badge/:id/avg-response/:duration?", cache("5 minutes"), async (request, response) => {
+    allowAllOrigin(response);
+
+    const {
+        label,
+        labelPrefix,
+        labelSuffix,
+        prefix,
+        suffix = badgeConstants.defaultPingValueSuffix,
+        color = badgeConstants.defaultPingColor,
+        labelColor,
+        style = badgeConstants.defaultStyle,
+        value, // for demo purpose only
+    } = request.query;
+
+    try {
+        const requestedMonitorId = parseInt(request.params.id, 10);
+
+        // Default duration is 24 (h) if not defined in queryParam, limited to 720h (30d)
+        const requestedDuration = Math.min(
+            request.params.duration
+                ? parseInt(request.params.duration, 10)
+                : 24,
+            720
+        );
+        const overrideValue = value && parseFloat(value);
+
+        const publicAvgPing = parseInt(await R.getCell(`
+            SELECT AVG(ping) FROM monitor_group, \`group\`, heartbeat
+            WHERE monitor_group.group_id = \`group\`.id
+            AND heartbeat.time > DATETIME('now', ? || ' hours')
+            AND heartbeat.ping IS NOT NULL
+            AND public = 1
+            AND heartbeat.monitor_id = ?
+            `,
+        [ -requestedDuration, requestedMonitorId ]
+        ));
+
+        const badgeValues = { style };
+
+        if (!publicAvgPing) {
+            // return a "N/A" badge in naColor (grey), if monitor is not public / not available / non existent
+
+            badgeValues.message = "N/A";
+            badgeValues.color = badgeConstants.naColor;
+        } else {
+            const avgPing = parseInt(overrideValue ?? publicAvgPing);
+
+            badgeValues.color = color;
+            // use a given, custom labelColor or use the default badge label color (defined by badge-maker)
+            badgeValues.labelColor = labelColor ?? "";
+            // build a label string. If a custom label is given, override the default one (requestedDuration)
+            badgeValues.label = filterAndJoin([
+                labelPrefix,
+                label ?? `Avg. Response (${requestedDuration}h)`,
+                labelSuffix,
+            ]);
+            badgeValues.message = filterAndJoin([ prefix, avgPing, suffix ]);
+        }
+
+        // build the SVG based on given values
+        const svg = makeBadge(badgeValues);
+
+        response.type("image/svg+xml");
+        response.send(svg);
+    } catch (error) {
+        sendHttpError(response, error.message);
+    }
+});
+
+router.get("/api/badge/:id/cert-exp", cache("5 minutes"), async (request, response) => {
+    allowAllOrigin(response);
+
+    const date = request.query.date;
+
+    const {
+        label,
+        labelPrefix,
+        labelSuffix,
+        prefix,
+        suffix = date ? "" : badgeConstants.defaultCertExpValueSuffix,
+        upColor = badgeConstants.defaultUpColor,
+        warnColor = badgeConstants.defaultWarnColor,
+        downColor = badgeConstants.defaultDownColor,
+        warnDays = badgeConstants.defaultCertExpireWarnDays,
+        downDays = badgeConstants.defaultCertExpireDownDays,
+        labelColor,
+        style = badgeConstants.defaultStyle,
+        value, // for demo purpose only
+    } = request.query;
+
+    try {
+        const requestedMonitorId = parseInt(request.params.id, 10);
+
+        const overrideValue = value && parseFloat(value);
+
+        let publicMonitor = await R.getRow(`
             SELECT monitor_group.monitor_id FROM monitor_group, \`group\`
             WHERE monitor_group.group_id = \`group\`.id
+            AND monitor_group.monitor_id = ?
             AND public = 1
-        `);
+            `,
+        [ requestedMonitorId ]
+        );
 
-        for (let monitorID of monitorIDList) {
-            let list = await R.getAll(`
-                    SELECT * FROM heartbeat
-                    WHERE monitor_id = ?
-                    ORDER BY time DESC
-                    LIMIT 50
-            `, [
-                monitorID,
+        const badgeValues = { style };
+
+        if (!publicMonitor) {
+            // return a "N/A" badge in naColor (grey), if monitor is not public / not available / non existent
+
+            badgeValues.message = "N/A";
+            badgeValues.color = badgeConstants.naColor;
+        } else {
+            const tlsInfoBean = await R.findOne("monitor_tls_info", "monitor_id = ?", [
+                requestedMonitorId,
             ]);
 
-            list = R.convertToBeans("heartbeat", list);
-            heartbeatList[monitorID] = list.reverse().map(row => row.toPublicJSON());
+            if (!tlsInfoBean) {
+                // return a "No/Bad Cert" badge in naColor (grey), if no cert saved (does not save bad certs?)
+                badgeValues.message = "No/Bad Cert";
+                badgeValues.color = badgeConstants.naColor;
+            } else {
+                const tlsInfo = JSON.parse(tlsInfoBean.info_json);
 
-            const type = 24;
-            uptimeList[`${monitorID}_${type}`] = await Monitor.calcUptime(type, monitorID);
+                if (!tlsInfo.valid) {
+                    // return a "Bad Cert" badge in naColor (grey), when cert is not valid
+                    badgeValues.message = "Bad Cert";
+                    badgeValues.color = badgeConstants.downColor;
+                } else {
+                    const daysRemaining = parseInt(overrideValue ?? tlsInfo.certInfo.daysRemaining);
+
+                    if (daysRemaining > warnDays) {
+                        badgeValues.color = upColor;
+                    } else if (daysRemaining > downDays) {
+                        badgeValues.color = warnColor;
+                    } else {
+                        badgeValues.color = downColor;
+                    }
+                    // use a given, custom labelColor or use the default badge label color (defined by badge-maker)
+                    badgeValues.labelColor = labelColor ?? "";
+                    // build a label string. If a custom label is given, override the default one
+                    badgeValues.label = filterAndJoin([
+                        labelPrefix,
+                        label ?? "Cert Exp.",
+                        labelSuffix,
+                    ]);
+                    badgeValues.message = filterAndJoin([ prefix, date ? tlsInfo.certInfo.validTo : daysRemaining, suffix ]);
+                }
+            }
         }
 
-        response.json({
-            heartbeatList,
-            uptimeList
-        });
+        // build the SVG based on given values
+        const svg = makeBadge(badgeValues);
 
+        response.type("image/svg+xml");
+        response.send(svg);
     } catch (error) {
-        send403(response, error.message);
+        sendHttpError(response, error.message);
     }
 });
 
-async function checkPublished() {
-    if (! await isPublished()) {
-        throw new Error("The status page is not published");
-    }
-}
+router.get("/api/badge/:id/response", cache("5 minutes"), async (request, response) => {
+    allowAllOrigin(response);
 
-/**
- * Default is published
- * @returns {Promise<boolean>}
- */
-async function isPublished() {
-    const value = await setting("statusPagePublished");
-    if (value === null) {
-        return true;
-    }
-    return value;
-}
+    const {
+        label,
+        labelPrefix,
+        labelSuffix,
+        prefix,
+        suffix = badgeConstants.defaultPingValueSuffix,
+        color = badgeConstants.defaultPingColor,
+        labelColor,
+        style = badgeConstants.defaultStyle,
+        value, // for demo purpose only
+    } = request.query;
 
-function send403(res, msg = "") {
-    res.status(403).json({
-        "status": "fail",
-        "msg": msg,
-    });
-}
+    try {
+        const requestedMonitorId = parseInt(request.params.id, 10);
+
+        const overrideValue = value && parseFloat(value);
+
+        let publicMonitor = await R.getRow(`
+            SELECT monitor_group.monitor_id FROM monitor_group, \`group\`
+            WHERE monitor_group.group_id = \`group\`.id
+            AND monitor_group.monitor_id = ?
+            AND public = 1
+            `,
+        [ requestedMonitorId ]
+        );
+
+        const badgeValues = { style };
+
+        if (!publicMonitor) {
+            // return a "N/A" badge in naColor (grey), if monitor is not public / not available / non existent
+
+            badgeValues.message = "N/A";
+            badgeValues.color = badgeConstants.naColor;
+        } else {
+            const heartbeat = await Monitor.getPreviousHeartbeat(
+                requestedMonitorId
+            );
+
+            if (!heartbeat.ping) {
+                // return a "N/A" badge in naColor (grey), if previous heartbeat has no ping
+
+                badgeValues.message = "N/A";
+                badgeValues.color = badgeConstants.naColor;
+            } else {
+                const ping = parseInt(overrideValue ?? heartbeat.ping);
+
+                badgeValues.color = color;
+                // use a given, custom labelColor or use the default badge label color (defined by badge-maker)
+                badgeValues.labelColor = labelColor ?? "";
+                // build a label string. If a custom label is given, override the default one
+                badgeValues.label = filterAndJoin([
+                    labelPrefix,
+                    label ?? "Response",
+                    labelSuffix,
+                ]);
+                badgeValues.message = filterAndJoin([ prefix, ping, suffix ]);
+            }
+        }
+
+        // build the SVG based on given values
+        const svg = makeBadge(badgeValues);
+
+        response.type("image/svg+xml");
+        response.send(svg);
+    } catch (error) {
+        sendHttpError(response, error.message);
+    }
+});
 
 module.exports = router;

server/routers/status-page-router.js

@@ -0,0 +1,142 @@
+let express = require("express");
+const apicache = require("../modules/apicache");
+const { UptimeKumaServer } = require("../uptime-kuma-server");
+const StatusPage = require("../model/status_page");
+const { allowDevAllOrigin, sendHttpError } = require("../util-server");
+const { R } = require("redbean-node");
+const Monitor = require("../model/monitor");
+
+let router = express.Router();
+
+let cache = apicache.middleware;
+const server = UptimeKumaServer.getInstance();
+
+router.get("/status/:slug", cache("5 minutes"), async (request, response) => {
+    let slug = request.params.slug;
+    await StatusPage.handleStatusPageResponse(response, server.indexHTML, slug);
+});
+
+router.get("/status", cache("5 minutes"), async (request, response) => {
+    let slug = "default";
+    await StatusPage.handleStatusPageResponse(response, server.indexHTML, slug);
+});
+
+router.get("/status-page", cache("5 minutes"), async (request, response) => {
+    let slug = "default";
+    await StatusPage.handleStatusPageResponse(response, server.indexHTML, slug);
+});
+
+// Status page config, incident, monitor list
+router.get("/api/status-page/:slug", cache("5 minutes"), async (request, response) => {
+    allowDevAllOrigin(response);
+    let slug = request.params.slug;
+
+    try {
+        // Get Status Page
+        let statusPage = await R.findOne("status_page", " slug = ? ", [
+            slug
+        ]);
+
+        if (!statusPage) {
+            return null;
+        }
+
+        let statusPageData = await StatusPage.getStatusPageData(statusPage);
+
+        if (!statusPageData) {
+            sendHttpError(response, "Not Found");
+            return;
+        }
+
+        // Response
+        response.json(statusPageData);
+
+    } catch (error) {
+        sendHttpError(response, error.message);
+    }
+});
+
+// Status Page Polling Data
+// Can fetch only if published
+router.get("/api/status-page/heartbeat/:slug", cache("1 minutes"), async (request, response) => {
+    allowDevAllOrigin(response);
+
+    try {
+        let heartbeatList = {};
+        let uptimeList = {};
+
+        let slug = request.params.slug;
+        let statusPageID = await StatusPage.slugToID(slug);
+
+        let monitorIDList = await R.getCol(`
+            SELECT monitor_group.monitor_id FROM monitor_group, \`group\`
+            WHERE monitor_group.group_id = \`group\`.id
+            AND public = 1
+            AND \`group\`.status_page_id = ?
+        `, [
+            statusPageID
+        ]);
+
+        for (let monitorID of monitorIDList) {
+            let list = await R.getAll(`
+                    SELECT * FROM heartbeat
+                    WHERE monitor_id = ?
+                    ORDER BY time DESC
+                    LIMIT 50
+            `, [
+                monitorID,
+            ]);
+
+            list = R.convertToBeans("heartbeat", list);
+            heartbeatList[monitorID] = list.reverse().map(row => row.toPublicJSON());
+
+            const type = 24;
+            uptimeList[`${monitorID}_${type}`] = await Monitor.calcUptime(type, monitorID);
+        }
+
+        response.json({
+            heartbeatList,
+            uptimeList
+        });
+
+    } catch (error) {
+        sendHttpError(response, error.message);
+    }
+});
+
+// Status page's manifest.json
+router.get("/api/status-page/:slug/manifest.json", cache("1440 minutes"), async (request, response) => {
+    allowDevAllOrigin(response);
+    let slug = request.params.slug;
+
+    try {
+        // Get Status Page
+        let statusPage = await R.findOne("status_page", " slug = ? ", [
+            slug
+        ]);
+
+        if (!statusPage) {
+            sendHttpError(response, "Not Found");
+            return;
+        }
+
+        // Response
+        response.json({
+            "name": statusPage.title,
+            "start_url": "/status/" + statusPage.slug,
+            "display": "standalone",
+            "icons": [
+                {
+                    "src": statusPage.icon,
+                    "sizes": "128x128",
+                    "type": "image/png"
+                }
+            ]
+        });
+
+    } catch (error) {
+        sendHttpError(response, error.message);
+    }
+});
+
+module.exports = router;

server/settings.js

@@ -0,0 +1,172 @@
+const { R } = require("redbean-node");
+const { log } = require("../src/util");
+
+class Settings {
+
+    /**
+     *  Example:
+     *      {
+     *         key1: {
+     *             value: "value2",
+     *             timestamp: 12345678
+     *         },
+     *         key2: {
+     *             value: 2,
+     *             timestamp: 12345678
+     *         },
+     *     }
+     * @type {{}}
+     */
+    static cacheList = {
+
+    };
+
+    static cacheCleaner = null;
+
+    /**
+     * Retrieve value of setting based on key
+     * @param {string} key Key of setting to retrieve
+     * @returns {Promise<any>} Value
+     */
+    static async get(key) {
+
+        // Start cache clear if not started yet
+        if (!Settings.cacheCleaner) {
+            Settings.cacheCleaner = setInterval(() => {
+                log.debug("settings", "Cache Cleaner is just started.");
+                for (key in Settings.cacheList) {
+                    if (Date.now() - Settings.cacheList[key].timestamp > 60 * 1000) {
+                        log.debug("settings", "Cache Cleaner deleted: " + key);
+                        delete Settings.cacheList[key];
+                    }
+                }
+
+            }, 60 * 1000);
+        }
+
+        // Query from cache
+        if (key in Settings.cacheList) {
+            const v = Settings.cacheList[key].value;
+            log.debug("settings", `Get Setting (cache): ${key}: ${v}`);
+            return v;
+        }
+
+        let value = await R.getCell("SELECT `value` FROM setting WHERE `key` = ? ", [
+            key,
+        ]);
+
+        try {
+            const v = JSON.parse(value);
+            log.debug("settings", `Get Setting: ${key}: ${v}`);
+
+            Settings.cacheList[key] = {
+                value: v,
+                timestamp: Date.now()
+            };
+
+            return v;
+        } catch (e) {
+            return value;
+        }
+    }
+
+    /**
+     * Sets the specified setting to specified value
+     * @param {string} key Key of setting to set
+     * @param {any} value Value to set to
+     * @param {?string} type Type of setting
+     * @returns {Promise<void>}
+     */
+    static async set(key, value, type = null) {
+
+        let bean = await R.findOne("setting", " `key` = ? ", [
+            key,
+        ]);
+        if (!bean) {
+            bean = R.dispense("setting");
+            bean.key = key;
+        }
+        bean.type = type;
+        bean.value = JSON.stringify(value);
+        await R.store(bean);
+
+        Settings.deleteCache([ key ]);
+    }
+
+    /**
+     * Get settings based on type
+     * @param {string} type The type of setting
+     * @returns {Promise<Bean>}
+     */
+    static async getSettings(type) {
+        let list = await R.getAll("SELECT `key`, `value` FROM setting WHERE `type` = ? ", [
+            type,
+        ]);
+
+        let result = {};
+
+        for (let row of list) {
+            try {
+                result[row.key] = JSON.parse(row.value);
+            } catch (e) {
+                result[row.key] = row.value;
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Set settings based on type
+     * @param {string} type Type of settings to set
+     * @param {Object} data Values of settings
+     * @returns {Promise<void>}
+     */
+    static async setSettings(type, data) {
+        let keyList = Object.keys(data);
+
+        let promiseList = [];
+
+        for (let key of keyList) {
+            let bean = await R.findOne("setting", " `key` = ? ", [
+                key
+            ]);
+
+            if (bean == null) {
+                bean = R.dispense("setting");
+                bean.type = type;
+                bean.key = key;
+            }
+
+            if (bean.type === type) {
+                bean.value = JSON.stringify(data[key]);
+                promiseList.push(R.store(bean));
+            }
+        }
+
+        await Promise.all(promiseList);
+
+        Settings.deleteCache(keyList);
+    }
+
+    /**
+     *
+     * @param {string[]} keyList
+     */
+    static deleteCache(keyList) {
+        for (let key of keyList) {
+            delete Settings.cacheList[key];
+        }
+    }
+
+    static stopCacheCleaner() {
+        if (Settings.cacheCleaner) {
+            clearInterval(Settings.cacheCleaner);
+            Settings.cacheCleaner = null;
+        }
+    }
+}
+
+module.exports = {
+    Settings,
+};

server/socket-handlers/cloudflared-socket-handler.js

@@ -0,0 +1,115 @@
+const { checkLogin, setSetting, setting, doubleCheckPassword } = require("../util-server");
+const { CloudflaredTunnel } = require("node-cloudflared-tunnel");
+const { UptimeKumaServer } = require("../uptime-kuma-server");
+const { log } = require("../../src/util");
+const io = UptimeKumaServer.getInstance().io;
+
+const prefix = "cloudflared_";
+const cloudflared = new CloudflaredTunnel();
+
+/**
+ * Change running state
+ * @param {string} running Is it running?
+ * @param {string} message Message to pass
+ */
+cloudflared.change = (running, message) => {
+    io.to("cloudflared").emit(prefix + "running", running);
+    io.to("cloudflared").emit(prefix + "message", message);
+};
+
+/**
+ * Emit an error message
+ * @param {string} errorMessage
+ */
+cloudflared.error = (errorMessage) => {
+    io.to("cloudflared").emit(prefix + "errorMessage", errorMessage);
+};
+
+/**
+ * Handler for cloudflared
+ * @param {Socket} socket Socket.io instance
+ */
+module.exports.cloudflaredSocketHandler = (socket) => {
+
+    socket.on(prefix + "join", async () => {
+        try {
+            checkLogin(socket);
+            socket.join("cloudflared");
+            io.to(socket.userID).emit(prefix + "installed", cloudflared.checkInstalled());
+            io.to(socket.userID).emit(prefix + "running", cloudflared.running);
+            io.to(socket.userID).emit(prefix + "token", await setting("cloudflaredTunnelToken"));
+        } catch (error) { }
+    });
+
+    socket.on(prefix + "leave", async () => {
+        try {
+            checkLogin(socket);
+            socket.leave("cloudflared");
+        } catch (error) { }
+    });
+
+    socket.on(prefix + "start", async (token) => {
+        try {
+            checkLogin(socket);
+            if (token && typeof token === "string") {
+                await setSetting("cloudflaredTunnelToken", token);
+                cloudflared.token = token;
+            } else {
+                cloudflared.token = null;
+            }
+            cloudflared.start();
+        } catch (error) { }
+    });
+
+    socket.on(prefix + "stop", async (currentPassword, callback) => {
+        try {
+            checkLogin(socket);
+            const disabledAuth = await setting("disableAuth");
+            if (!disabledAuth) {
+                await doubleCheckPassword(socket, currentPassword);
+            }
+            cloudflared.stop();
+        } catch (error) {
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
+
+    socket.on(prefix + "removeToken", async () => {
+        try {
+            checkLogin(socket);
+            await setSetting("cloudflaredTunnelToken", "");
+        } catch (error) { }
+    });
+
+};
+
+/**
+ * Automatically start cloudflared
+ * @param {string} token Cloudflared tunnel token
+ */
+module.exports.autoStart = async (token) => {
+    if (!token) {
+        token = await setting("cloudflaredTunnelToken");
+    } else {
+        // Override the current token via args or env var
+        await setSetting("cloudflaredTunnelToken", token);
+        console.log("Use cloudflared token from args or env var");
+    }
+
+    if (token) {
+        console.log("Start cloudflared");
+        cloudflared.token = token;
+        cloudflared.start();
+    }
+};
+
+/** Stop cloudflared */
+module.exports.stop = async () => {
+    log.info("cloudflared", "Stop cloudflared");
+    if (cloudflared) {
+        cloudflared.stop();
+    }
+};

server/socket-handlers/database-socket-handler.js

@@ -1,6 +1,10 @@
 const { checkLogin } = require("../util-server");
 const Database = require("../database");
 
+/**
+ * Handlers for database
+ * @param {Socket} socket Socket.io instance
+ */
 module.exports = (socket) => {
 
     // Post or edit incident

server/socket-handlers/docker-socket-handler.js

@@ -0,0 +1,79 @@
+const { sendDockerHostList } = require("../client");
+const { checkLogin } = require("../util-server");
+const { DockerHost } = require("../docker");
+const { log } = require("../../src/util");
+
+/**
+ * Handlers for docker hosts
+ * @param {Socket} socket Socket.io instance
+ */
+module.exports.dockerSocketHandler = (socket) => {
+    socket.on("addDockerHost", async (dockerHost, dockerHostID, callback) => {
+        try {
+            checkLogin(socket);
+
+            let dockerHostBean = await DockerHost.save(dockerHost, dockerHostID, socket.userID);
+            await sendDockerHostList(socket);
+
+            callback({
+                ok: true,
+                msg: "Saved",
+                id: dockerHostBean.id,
+            });
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("deleteDockerHost", async (dockerHostID, callback) => {
+        try {
+            checkLogin(socket);
+
+            await DockerHost.delete(dockerHostID, socket.userID);
+            await sendDockerHostList(socket);
+
+            callback({
+                ok: true,
+                msg: "Deleted",
+            });
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("testDockerHost", async (dockerHost, callback) => {
+        try {
+            checkLogin(socket);
+
+            let amount = await DockerHost.testDockerHost(dockerHost);
+            let msg;
+
+            if (amount >= 1) {
+                msg = "Connected Successfully. Amount of containers: " + amount;
+            } else {
+                msg = "Connected Successfully, but there are no containers?";
+            }
+
+            callback({
+                ok: true,
+                msg,
+            });
+
+        } catch (e) {
+            log.error("docker", e);
+
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+};

server/socket-handlers/general-socket-handler.js

@@ -0,0 +1,50 @@
+const { log } = require("../../src/util");
+const { Settings } = require("../settings");
+const { sendInfo } = require("../client");
+const { checkLogin } = require("../util-server");
+const GameResolver = require("gamedig/lib/GameResolver");
+
+let gameResolver = new GameResolver();
+let gameList = null;
+
+/**
+ * Get a game list via GameDig
+ * @returns {Object[]} list of games supported by GameDig
+ */
+function getGameList() {
+    if (gameList == null) {
+        gameList = gameResolver._readGames().games.sort((a, b) => {
+            if ( a.pretty < b.pretty ) {
+                return -1;
+            }
+            if ( a.pretty > b.pretty ) {
+                return 1;
+            }
+            return 0;
+        });
+    }
+    return gameList;
+}
+
+module.exports.generalSocketHandler = (socket, server) => {
+
+    socket.on("initServerTimezone", async (timezone) => {
+        try {
+            checkLogin(socket);
+            log.debug("generalSocketHandler", "Timezone: " + timezone);
+            await Settings.set("initServerTimezone", true);
+            await server.setTimezone(timezone);
+            await sendInfo(socket);
+        } catch (e) {
+            log.warn("initServerTimezone", e.message);
+        }
+    });
+
+    socket.on("getGameList", async (callback) => {
+        callback({
+            ok: true,
+            gameList: getGameList(),
+        });
+    });
+
+};

server/socket-handlers/maintenance-socket-handler.js

@@ -0,0 +1,317 @@
+const { checkLogin } = require("../util-server");
+const { log } = require("../../src/util");
+const { R } = require("redbean-node");
+const apicache = require("../modules/apicache");
+const { UptimeKumaServer } = require("../uptime-kuma-server");
+const Maintenance = require("../model/maintenance");
+const server = UptimeKumaServer.getInstance();
+const MaintenanceTimeslot = require("../model/maintenance_timeslot");
+
+/**
+ * Handlers for Maintenance
+ * @param {Socket} socket Socket.io instance
+ */
+module.exports.maintenanceSocketHandler = (socket) => {
+    // Add a new maintenance
+    socket.on("addMaintenance", async (maintenance, callback) => {
+        try {
+            checkLogin(socket);
+
+            log.debug("maintenance", maintenance);
+
+            let bean = Maintenance.jsonToBean(R.dispense("maintenance"), maintenance);
+            bean.user_id = socket.userID;
+            let maintenanceID = await R.store(bean);
+            await MaintenanceTimeslot.generateTimeslot(bean);
+
+            await server.sendMaintenanceList(socket);
+
+            callback({
+                ok: true,
+                msg: "Added Successfully.",
+                maintenanceID,
+            });
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    // Edit a maintenance
+    socket.on("editMaintenance", async (maintenance, callback) => {
+        try {
+            checkLogin(socket);
+
+            let bean = await R.findOne("maintenance", " id = ? ", [ maintenance.id ]);
+
+            if (bean.user_id !== socket.userID) {
+                throw new Error("Permission denied.");
+            }
+
+            Maintenance.jsonToBean(bean, maintenance);
+
+            await R.store(bean);
+            await MaintenanceTimeslot.generateTimeslot(bean, null, true);
+
+            await server.sendMaintenanceList(socket);
+
+            callback({
+                ok: true,
+                msg: "Saved.",
+                maintenanceID: bean.id,
+            });
+
+        } catch (e) {
+            console.error(e);
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    // Add a new monitor_maintenance
+    socket.on("addMonitorMaintenance", async (maintenanceID, monitors, callback) => {
+        try {
+            checkLogin(socket);
+
+            await R.exec("DELETE FROM monitor_maintenance WHERE maintenance_id = ?", [
+                maintenanceID
+            ]);
+
+            for await (const monitor of monitors) {
+                let bean = R.dispense("monitor_maintenance");
+
+                bean.import({
+                    monitor_id: monitor.id,
+                    maintenance_id: maintenanceID
+                });
+                await R.store(bean);
+            }
+
+            apicache.clear();
+
+            callback({
+                ok: true,
+                msg: "Added Successfully.",
+            });
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    // Add a new monitor_maintenance
+    socket.on("addMaintenanceStatusPage", async (maintenanceID, statusPages, callback) => {
+        try {
+            checkLogin(socket);
+
+            await R.exec("DELETE FROM maintenance_status_page WHERE maintenance_id = ?", [
+                maintenanceID
+            ]);
+
+            for await (const statusPage of statusPages) {
+                let bean = R.dispense("maintenance_status_page");
+
+                bean.import({
+                    status_page_id: statusPage.id,
+                    maintenance_id: maintenanceID
+                });
+                await R.store(bean);
+            }
+
+            apicache.clear();
+
+            callback({
+                ok: true,
+                msg: "Added Successfully.",
+            });
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("getMaintenance", async (maintenanceID, callback) => {
+        try {
+            checkLogin(socket);
+
+            log.debug("maintenance", `Get Maintenance: ${maintenanceID} User ID: ${socket.userID}`);
+
+            let bean = await R.findOne("maintenance", " id = ? AND user_id = ? ", [
+                maintenanceID,
+                socket.userID,
+            ]);
+
+            callback({
+                ok: true,
+                maintenance: await bean.toJSON(),
+            });
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("getMaintenanceList", async (callback) => {
+        try {
+            checkLogin(socket);
+            await server.sendMaintenanceList(socket);
+            callback({
+                ok: true,
+            });
+        } catch (e) {
+            console.error(e);
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("getMonitorMaintenance", async (maintenanceID, callback) => {
+        try {
+            checkLogin(socket);
+
+            log.debug("maintenance", `Get Monitors for Maintenance: ${maintenanceID} User ID: ${socket.userID}`);
+
+            let monitors = await R.getAll("SELECT monitor.id, monitor.name FROM monitor_maintenance mm JOIN monitor ON mm.monitor_id = monitor.id WHERE mm.maintenance_id = ? ", [
+                maintenanceID,
+            ]);
+
+            callback({
+                ok: true,
+                monitors,
+            });
+
+        } catch (e) {
+            console.error(e);
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("getMaintenanceStatusPage", async (maintenanceID, callback) => {
+        try {
+            checkLogin(socket);
+
+            log.debug("maintenance", `Get Status Pages for Maintenance: ${maintenanceID} User ID: ${socket.userID}`);
+
+            let statusPages = await R.getAll("SELECT status_page.id, status_page.title FROM maintenance_status_page msp JOIN status_page ON msp.status_page_id = status_page.id WHERE msp.maintenance_id = ? ", [
+                maintenanceID,
+            ]);
+
+            callback({
+                ok: true,
+                statusPages,
+            });
+
+        } catch (e) {
+            console.error(e);
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("deleteMaintenance", async (maintenanceID, callback) => {
+        try {
+            checkLogin(socket);
+
+            log.debug("maintenance", `Delete Maintenance: ${maintenanceID} User ID: ${socket.userID}`);
+
+            if (maintenanceID in server.maintenanceList) {
+                delete server.maintenanceList[maintenanceID];
+            }
+
+            await R.exec("DELETE FROM maintenance WHERE id = ? AND user_id = ? ", [
+                maintenanceID,
+                socket.userID,
+            ]);
+
+            apicache.clear();
+
+            callback({
+                ok: true,
+                msg: "Deleted Successfully.",
+            });
+
+            await server.sendMaintenanceList(socket);
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("pauseMaintenance", async (maintenanceID, callback) => {
+        try {
+            checkLogin(socket);
+
+            log.debug("maintenance", `Pause Maintenance: ${maintenanceID} User ID: ${socket.userID}`);
+
+            await R.exec("UPDATE maintenance SET active = 0 WHERE id = ? ", [
+                maintenanceID,
+            ]);
+
+            apicache.clear();
+
+            callback({
+                ok: true,
+                msg: "Paused Successfully.",
+            });
+
+            await server.sendMaintenanceList(socket);
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("resumeMaintenance", async (maintenanceID, callback) => {
+        try {
+            checkLogin(socket);
+
+            log.debug("maintenance", `Resume Maintenance: ${maintenanceID} User ID: ${socket.userID}`);
+
+            await R.exec("UPDATE maintenance SET active = 1 WHERE id = ? ", [
+                maintenanceID,
+            ]);
+
+            apicache.clear();
+
+            callback({
+                ok: true,
+                msg: "Resume Successfully",
+            });
+
+            await server.sendMaintenanceList(socket);
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+};

server/socket-handlers/plugins-handler.js

@@ -0,0 +1,69 @@
+const { checkLogin } = require("../util-server");
+const { PluginsManager } = require("../plugins-manager");
+const { log } = require("../../src/util.js");
+
+/**
+ * Handlers for plugins
+ * @param {Socket} socket Socket.io instance
+ * @param {UptimeKumaServer} server
+ */
+module.exports.pluginsHandler = (socket, server) => {
+
+    const pluginManager = server.getPluginManager();
+
+    // Get Plugin List
+    socket.on("getPluginList", async (callback) => {
+        try {
+            checkLogin(socket);
+
+            log.debug("plugin", "PluginManager.disable: " + PluginsManager.disable);
+
+            if (PluginsManager.disable) {
+                throw new Error("Plugin Disabled: In order to enable plugin feature, you need to use the default data directory: ./data/");
+            }
+
+            let pluginList = await pluginManager.fetchPluginList();
+            callback({
+                ok: true,
+                pluginList,
+            });
+        } catch (error) {
+            log.warn("plugin", "Error: " + error.message);
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
+
+    socket.on("installPlugin", async (repoURL, name, callback) => {
+        try {
+            checkLogin(socket);
+            pluginManager.downloadPlugin(repoURL, name);
+            await pluginManager.loadPlugin(name);
+            callback({
+                ok: true,
+            });
+        } catch (error) {
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
+
+    socket.on("uninstallPlugin", async (name, callback) => {
+        try {
+            checkLogin(socket);
+            await pluginManager.removePlugin(name);
+            callback({
+                ok: true,
+            });
+        } catch (error) {
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
+};

server/socket-handlers/proxy-socket-handler.js

@@ -0,0 +1,58 @@
+const { checkLogin } = require("../util-server");
+const { Proxy } = require("../proxy");
+const { sendProxyList } = require("../client");
+const { UptimeKumaServer } = require("../uptime-kuma-server");
+const server = UptimeKumaServer.getInstance();
+
+/**
+ * Handlers for proxy
+ * @param {Socket} socket Socket.io instance
+ */
+module.exports.proxySocketHandler = (socket) => {
+    socket.on("addProxy", async (proxy, proxyID, callback) => {
+        try {
+            checkLogin(socket);
+
+            const proxyBean = await Proxy.save(proxy, proxyID, socket.userID);
+            await sendProxyList(socket);
+
+            if (proxy.applyExisting) {
+                await Proxy.reloadProxy();
+                await server.sendMonitorList(socket);
+            }
+
+            callback({
+                ok: true,
+                msg: "Saved",
+                id: proxyBean.id,
+            });
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("deleteProxy", async (proxyID, callback) => {
+        try {
+            checkLogin(socket);
+
+            await Proxy.delete(proxyID, socket.userID);
+            await sendProxyList(socket);
+            await Proxy.reloadProxy();
+
+            callback({
+                ok: true,
+                msg: "Deleted",
+            });
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+};

server/socket-handlers/status-page-socket-handler.js

@@ -1,25 +1,40 @@
 const { R } = require("redbean-node");
-const { checkLogin, setSettings } = require("../util-server");
+const { checkLogin, setSetting } = require("../util-server");
 const dayjs = require("dayjs");
-const { debug } = require("../../src/util");
+const { log } = require("../../src/util");
 const ImageDataURI = require("../image-data-uri");
 const Database = require("../database");
 const apicache = require("../modules/apicache");
+const StatusPage = require("../model/status_page");
+const { UptimeKumaServer } = require("../uptime-kuma-server");
 
+/**
+ * Socket handlers for status page
+ * @param {Socket} socket Socket.io instance to add listeners on
+ */
 module.exports.statusPageSocketHandler = (socket) => {
 
     // Post or edit incident
-    socket.on("postIncident", async (incident, callback) => {
+    socket.on("postIncident", async (slug, incident, callback) => {
         try {
             checkLogin(socket);
 
-            await R.exec("UPDATE incident SET pin = 0 ");
+            let statusPageID = await StatusPage.slugToID(slug);
+
+            if (!statusPageID) {
+                throw new Error("slug is not found");
+            }
+
+            await R.exec("UPDATE incident SET pin = 0 WHERE status_page_id = ? ", [
+                statusPageID
+            ]);
 
             let incidentBean;
 
             if (incident.id) {
-                incidentBean = await R.findOne("incident", " id = ?", [
-                    incident.id
+                incidentBean = await R.findOne("incident", " id = ? AND status_page_id = ? ", [
+                    incident.id,
+                    statusPageID
                 ]);
             }
 
@@ -31,6 +46,7 @@ module.exports.statusPageSocketHandler = (socket) => {
             incidentBean.content = incident.content;
             incidentBean.style = incident.style;
             incidentBean.pin = true;
+            incidentBean.status_page_id = statusPageID;
 
             if (incident.id) {
                 incidentBean.lastUpdatedDate = R.isoDateTime(dayjs.utc());
@@ -52,11 +68,15 @@ module.exports.statusPageSocketHandler = (socket) => {
         }
     });
 
-    socket.on("unpinIncident", async (callback) => {
+    socket.on("unpinIncident", async (slug, callback) => {
         try {
             checkLogin(socket);
 
-            await R.exec("UPDATE incident SET pin = 0 WHERE pin = 1");
+            let statusPageID = await StatusPage.slugToID(slug);
+
+            await R.exec("UPDATE incident SET pin = 0 WHERE pin = 1 AND status_page_id = ? ", [
+                statusPageID
+            ]);
 
             callback({
                 ok: true,
@@ -69,14 +89,46 @@ module.exports.statusPageSocketHandler = (socket) => {
         }
     });
 
+    socket.on("getStatusPage", async (slug, callback) => {
+        try {
+            checkLogin(socket);
+
+            let statusPage = await R.findOne("status_page", " slug = ? ", [
+                slug
+            ]);
+
+            if (!statusPage) {
+                throw new Error("No slug?");
+            }
+
+            callback({
+                ok: true,
+                config: await statusPage.toJSON(),
+            });
+        } catch (error) {
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
+
     // Save Status Page
     // imgDataUrl Only Accept PNG!
-    socket.on("saveStatusPage", async (config, imgDataUrl, publicGroupList, callback) => {
-
+    socket.on("saveStatusPage", async (slug, config, imgDataUrl, publicGroupList, callback) => {
         try {
             checkLogin(socket);
 
-            apicache.clear();
+            // Save Config
+            let statusPage = await R.findOne("status_page", " slug = ? ", [
+                slug
+            ]);
+
+            if (!statusPage) {
+                throw new Error("No slug?");
+            }
+
+            checkSlug(config.slug);
 
             const header = "data:image/png;base64,";
 
@@ -88,16 +140,35 @@ module.exports.statusPageSocketHandler = (socket) => {
                     throw new Error("Only allowed PNG logo.");
                 }
 
+                const filename = `logo${statusPage.id}.png`;
+
                 // Convert to file
-                await ImageDataURI.outputFile(imgDataUrl, Database.uploadDir + "logo.png");
-                config.logo = "/upload/logo.png?t=" + Date.now();
+                await ImageDataURI.outputFile(imgDataUrl, Database.uploadDir + filename);
+                config.logo = `/upload/${filename}?t=` + Date.now();
 
             } else {
                 config.icon = imgDataUrl;
             }
 
-            // Save Config
-            await setSettings("statusPage", config);
+            statusPage.slug = config.slug;
+            statusPage.title = config.title;
+            statusPage.description = config.description;
+            statusPage.icon = config.logo;
+            statusPage.theme = config.theme;
+            //statusPage.published = ;
+            //statusPage.search_engine_index = ;
+            statusPage.show_tags = config.showTags;
+            //statusPage.password = null;
+            statusPage.footer_text = config.footerText;
+            statusPage.custom_css = config.customCSS;
+            statusPage.show_powered_by = config.showPoweredBy;
+            statusPage.modified_date = R.isoDateTime();
+            statusPage.google_analytics_tag_id = config.googleAnalyticsId;
+
+            await R.store(statusPage);
+
+            await statusPage.updateDomainNameList(config.domainNameList);
+            await StatusPage.loadDomainMappingList();
 
             // Save Public Group List
             const groupIDList = [];
@@ -106,13 +177,15 @@ module.exports.statusPageSocketHandler = (socket) => {
             for (let group of publicGroupList) {
                 let groupBean;
                 if (group.id) {
-                    groupBean = await R.findOne("group", " id = ? AND public = 1 ", [
-                        group.id
+                    groupBean = await R.findOne("group", " id = ? AND public = 1 AND status_page_id = ? ", [
+                        group.id,
+                        statusPage.id
                     ]);
                 } else {
                     groupBean = R.dispense("group");
                 }
 
+                groupBean.status_page_id = statusPage.id;
                 groupBean.name = group.name;
                 groupBean.public = true;
                 groupBean.weight = groupOrder++;
@@ -124,13 +197,17 @@ module.exports.statusPageSocketHandler = (socket) => {
                 ]);
 
                 let monitorOrder = 1;
-                console.log(group.monitorList);
 
                 for (let monitor of group.monitorList) {
                     let relationBean = R.dispense("monitor_group");
                     relationBean.weight = monitorOrder++;
                     relationBean.group_id = groupBean.id;
                     relationBean.monitor_id = monitor.id;
+
+                    if (monitor.sendUrl !== undefined) {
+                        relationBean.send_url = monitor.sendUrl;
+                    }
+
                     await R.store(relationBean);
                 }
 
@@ -138,10 +215,25 @@ module.exports.statusPageSocketHandler = (socket) => {
                 group.id = groupBean.id;
             }
 
-            // Delete groups that not in the list
-            debug("Delete groups that not in the list");
+            // Delete groups that are not in the list
+            log.debug("socket", "Delete groups that are not in the list");
             const slots = groupIDList.map(() => "?").join(",");
-            await R.exec(`DELETE FROM \`group\` WHERE id NOT IN (${slots})`, groupIDList);
+
+            const data = [
+                ...groupIDList,
+                statusPage.id
+            ];
+            await R.exec(`DELETE FROM \`group\` WHERE id NOT IN (${slots}) AND status_page_id = ?`, data);
+
+            const server = UptimeKumaServer.getInstance();
+
+            // Also change entry page to new slug if it is the default one, and slug is changed.
+            if (server.entryPage === "statusPage-" + slug && statusPage.slug !== slug) {
+                server.entryPage = "statusPage-" + statusPage.slug;
+                await setSetting("entryPage", server.entryPage, "general");
+            }
+
+            apicache.clear();
 
             callback({
                 ok: true,
@@ -149,7 +241,7 @@ module.exports.statusPageSocketHandler = (socket) => {
             });
 
         } catch (error) {
-            console.log(error);
+            log.error("socket", error);
 
             callback({
                 ok: false,
@@ -158,4 +250,118 @@ module.exports.statusPageSocketHandler = (socket) => {
         }
     });
 
+    // Add a new status page
+    socket.on("addStatusPage", async (title, slug, callback) => {
+        try {
+            checkLogin(socket);
+
+            title = title?.trim();
+            slug = slug?.trim();
+
+            // Check empty
+            if (!title || !slug) {
+                throw new Error("Please input all fields");
+            }
+
+            // Make sure slug is string
+            if (typeof slug !== "string") {
+                throw new Error("Slug -Accept string only");
+            }
+
+            // lower case only
+            slug = slug.toLowerCase();
+
+            checkSlug(slug);
+
+            let statusPage = R.dispense("status_page");
+            statusPage.slug = slug;
+            statusPage.title = title;
+            statusPage.theme = "light";
+            statusPage.icon = "";
+            await R.store(statusPage);
+
+            callback({
+                ok: true,
+                msg: "OK!"
+            });
+
+        } catch (error) {
+            console.error(error);
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
+
+    // Delete a status page
+    socket.on("deleteStatusPage", async (slug, callback) => {
+        const server = UptimeKumaServer.getInstance();
+
+        try {
+            checkLogin(socket);
+
+            let statusPageID = await StatusPage.slugToID(slug);
+
+            if (statusPageID) {
+
+                // Reset entry page if it is the default one.
+                if (server.entryPage === "statusPage-" + slug) {
+                    server.entryPage = "dashboard";
+                    await setSetting("entryPage", server.entryPage, "general");
+                }
+
+                // No need to delete records from `status_page_cname`, because it has cascade foreign key.
+                // But for incident & group, it is hard to add cascade foreign key during migration, so they have to be deleted manually.
+
+                // Delete incident
+                await R.exec("DELETE FROM incident WHERE status_page_id = ? ", [
+                    statusPageID
+                ]);
+
+                // Delete group
+                await R.exec("DELETE FROM `group` WHERE status_page_id = ? ", [
+                    statusPageID
+                ]);
+
+                // Delete status_page
+                await R.exec("DELETE FROM status_page WHERE id = ? ", [
+                    statusPageID
+                ]);
+
+            } else {
+                throw new Error("Status Page is not found");
+            }
+
+            callback({
+                ok: true,
+            });
+        } catch (error) {
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
 };
+
+/**
+ * Check slug a-z, 0-9, - only
+ * Regex from: https://stackoverflow.com/questions/22454258/js-regex-string-validation-for-slug
+ * @param {string} slug Slug to test
+ */
+function checkSlug(slug) {
+    if (typeof slug !== "string") {
+        throw new Error("Slug must be string");
+    }
+
+    slug = slug.trim();
+
+    if (!slug) {
+        throw new Error("Slug cannot be empty");
+    }
+
+    if (!slug.match(/^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$/)) {
+        throw new Error("Invalid Slug");
+    }
+}

server/uptime-cache-list.js

@@ -0,0 +1,49 @@
+const { log } = require("../src/util");
+class UptimeCacheList {
+    /**
+     * list[monitorID][duration]
+     */
+    static list = {};
+
+    /**
+     * Get the uptime for a specific period
+     * @param {number} monitorID
+     * @param {number} duration
+     * @return {number}
+     */
+    static getUptime(monitorID, duration) {
+        if (UptimeCacheList.list[monitorID] && UptimeCacheList.list[monitorID][duration]) {
+            log.debug("UptimeCacheList", "getUptime: " + monitorID + " " + duration);
+            return UptimeCacheList.list[monitorID][duration];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Add uptime for specified monitor
+     * @param {number} monitorID
+     * @param {number} duration
+     * @param {number} uptime Uptime to add
+     */
+    static addUptime(monitorID, duration, uptime) {
+        log.debug("UptimeCacheList", "addUptime: " + monitorID + " " + duration);
+        if (!UptimeCacheList.list[monitorID]) {
+            UptimeCacheList.list[monitorID] = {};
+        }
+        UptimeCacheList.list[monitorID][duration] = uptime;
+    }
+
+    /**
+     * Clear cache for specified monitor
+     * @param {number} monitorID
+     */
+    static clearCache(monitorID) {
+        log.debug("UptimeCacheList", "clearCache: " + monitorID);
+        delete UptimeCacheList.list[monitorID];
+    }
+}
+
+module.exports = {
+    UptimeCacheList,
+};

server/uptime-kuma-server.js

@@ -0,0 +1,338 @@
+const express = require("express");
+const https = require("https");
+const fs = require("fs");
+const http = require("http");
+const { Server } = require("socket.io");
+const { R } = require("redbean-node");
+const { log } = require("../src/util");
+const Database = require("./database");
+const util = require("util");
+const { CacheableDnsHttpAgent } = require("./cacheable-dns-http-agent");
+const { Settings } = require("./settings");
+const dayjs = require("dayjs");
+const { PluginsManager } = require("./plugins-manager");
+// DO NOT IMPORT HERE IF THE MODULES USED `UptimeKumaServer.getInstance()`
+
+/**
+ * `module.exports` (alias: `server`) should be inside this class, in order to avoid circular dependency issue.
+ * @type {UptimeKumaServer}
+ */
+class UptimeKumaServer {
+    /**
+     *
+     * @type {UptimeKumaServer}
+     */
+    static instance = null;
+
+    /**
+     * Main monitor list
+     * @type {{}}
+     */
+    monitorList = {};
+
+    /**
+     * Main maintenance list
+     * @type {{}}
+     */
+    maintenanceList = {};
+
+    entryPage = "dashboard";
+    app = undefined;
+    httpServer = undefined;
+    io = undefined;
+
+    /**
+     * Cache Index HTML
+     * @type {string}
+     */
+    indexHTML = "";
+
+    generateMaintenanceTimeslotsInterval = undefined;
+
+    /**
+     * Plugins Manager
+     * @type {PluginsManager}
+     */
+    pluginsManager = null;
+
+    /**
+     *
+     * @type {{}}
+     */
+    static monitorTypeList = {
+
+    };
+
+    static getInstance(args) {
+        if (UptimeKumaServer.instance == null) {
+            UptimeKumaServer.instance = new UptimeKumaServer(args);
+        }
+        return UptimeKumaServer.instance;
+    }
+
+    constructor(args) {
+        // SSL
+        const sslKey = args["ssl-key"] || process.env.UPTIME_KUMA_SSL_KEY || process.env.SSL_KEY || undefined;
+        const sslCert = args["ssl-cert"] || process.env.UPTIME_KUMA_SSL_CERT || process.env.SSL_CERT || undefined;
+
+        log.info("server", "Creating express and socket.io instance");
+        this.app = express();
+        if (sslKey && sslCert) {
+            log.info("server", "Server Type: HTTPS");
+            this.httpServer = https.createServer({
+                key: fs.readFileSync(sslKey),
+                cert: fs.readFileSync(sslCert)
+            }, this.app);
+        } else {
+            log.info("server", "Server Type: HTTP");
+            this.httpServer = http.createServer(this.app);
+        }
+
+        try {
+            this.indexHTML = fs.readFileSync("./dist/index.html").toString();
+        } catch (e) {
+            // "dist/index.html" is not necessary for development
+            if (process.env.NODE_ENV !== "development") {
+                log.error("server", "Error: Cannot find 'dist/index.html', did you install correctly?");
+                process.exit(1);
+            }
+        }
+
+        this.io = new Server(this.httpServer);
+    }
+
+    /** Initialise app after the database has been set up */
+    async initAfterDatabaseReady() {
+        await CacheableDnsHttpAgent.update();
+
+        process.env.TZ = await this.getTimezone();
+        dayjs.tz.setDefault(process.env.TZ);
+        log.debug("DEBUG", "Timezone: " + process.env.TZ);
+        log.debug("DEBUG", "Current Time: " + dayjs.tz().format());
+
+        await this.generateMaintenanceTimeslots();
+        this.generateMaintenanceTimeslotsInterval = setInterval(this.generateMaintenanceTimeslots, 60 * 1000);
+    }
+
+    /**
+     * Send list of monitors to client
+     * @param {Socket} socket
+     * @returns {Object} List of monitors
+     */
+    async sendMonitorList(socket) {
+        let list = await this.getMonitorJSONList(socket.userID);
+        this.io.to(socket.userID).emit("monitorList", list);
+        return list;
+    }
+
+    /**
+     * Get a list of monitors for the given user.
+     * @param {string} userID - The ID of the user to get monitors for.
+     * @returns {Promise<Object>} A promise that resolves to an object with monitor IDs as keys and monitor objects as values.
+     *
+     * Generated by Trelent
+     */
+    async getMonitorJSONList(userID) {
+        let result = {};
+
+        let monitorList = await R.find("monitor", " user_id = ? ORDER BY weight DESC, name", [
+            userID,
+        ]);
+
+        for (let monitor of monitorList) {
+            result[monitor.id] = await monitor.toJSON();
+        }
+
+        return result;
+    }
+
+    /**
+     * Send maintenance list to client
+     * @param {Socket} socket Socket.io instance to send to
+     * @returns {Object}
+     */
+    async sendMaintenanceList(socket) {
+        return await this.sendMaintenanceListByUserID(socket.userID);
+    }
+
+    /**
+     * Send list of maintenances to user
+     * @param {number} userID
+     * @returns {Object}
+     */
+    async sendMaintenanceListByUserID(userID) {
+        let list = await this.getMaintenanceJSONList(userID);
+        this.io.to(userID).emit("maintenanceList", list);
+        return list;
+    }
+
+    /**
+     * Get a list of maintenances for the given user.
+     * @param {string} userID - The ID of the user to get maintenances for.
+     * @returns {Promise<Object>} A promise that resolves to an object with maintenance IDs as keys and maintenances objects as values.
+     */
+    async getMaintenanceJSONList(userID) {
+        let result = {};
+
+        let maintenanceList = await R.find("maintenance", " user_id = ? ORDER BY end_date DESC, title", [
+            userID,
+        ]);
+
+        for (let maintenance of maintenanceList) {
+            result[maintenance.id] = await maintenance.toJSON();
+        }
+
+        return result;
+    }
+
+    /**
+     * Write error to log file
+     * @param {any} error The error to write
+     * @param {boolean} outputToConsole Should the error also be output to console?
+     */
+    static errorLog(error, outputToConsole = true) {
+        const errorLogStream = fs.createWriteStream(Database.dataDir + "/error.log", {
+            flags: "a"
+        });
+
+        errorLogStream.on("error", () => {
+            log.info("", "Cannot write to error.log");
+        });
+
+        if (errorLogStream) {
+            const dateTime = R.isoDateTime();
+            errorLogStream.write(`[${dateTime}] ` + util.format(error) + "\n");
+
+            if (outputToConsole) {
+                console.error(error);
+            }
+        }
+
+        errorLogStream.end();
+    }
+
+    /**
+     * Get the IP of the client connected to the socket
+     * @param {Socket} socket
+     * @returns {string}
+     */
+    async getClientIP(socket) {
+        let clientIP = socket.client.conn.remoteAddress;
+
+        if (clientIP === undefined) {
+            clientIP = "";
+        }
+
+        if (await Settings.get("trustProxy")) {
+            const forwardedFor = socket.client.conn.request.headers["x-forwarded-for"];
+
+            return (typeof forwardedFor === "string" ? forwardedFor.split(",")[0].trim() : null)
+                || socket.client.conn.request.headers["x-real-ip"]
+                || clientIP.replace(/^.*:/, "");
+        } else {
+            return clientIP.replace(/^.*:/, "");
+        }
+    }
+
+    /**
+     * Attempt to get the current server timezone
+     * If this fails, fall back to environment variables and then make a
+     * guess.
+     * @returns {string}
+     */
+    async getTimezone() {
+        let timezone = await Settings.get("serverTimezone");
+        if (timezone) {
+            return timezone;
+        } else if (process.env.TZ) {
+            return process.env.TZ;
+        } else {
+            return dayjs.tz.guess();
+        }
+    }
+
+    /**
+     * Get the current offset
+     * @returns {string}
+     */
+    getTimezoneOffset() {
+        return dayjs().format("Z");
+    }
+
+    /**
+     * Set the current server timezone and environment variables
+     * @param {string} timezone
+     */
+    async setTimezone(timezone) {
+        await Settings.set("serverTimezone", timezone, "general");
+        process.env.TZ = timezone;
+        dayjs.tz.setDefault(timezone);
+    }
+
+    /** Load the timeslots for maintenance */
+    async generateMaintenanceTimeslots() {
+
+        let list = await R.find("maintenance_timeslot", " generated_next = 0 AND start_date <= DATETIME('now') ");
+
+        for (let maintenanceTimeslot of list) {
+            let maintenance = await maintenanceTimeslot.maintenance;
+            await MaintenanceTimeslot.generateTimeslot(maintenance, maintenanceTimeslot.end_date, false);
+            maintenanceTimeslot.generated_next = true;
+            await R.store(maintenanceTimeslot);
+        }
+
+    }
+
+    /** Stop the server */
+    async stop() {
+        clearTimeout(this.generateMaintenanceTimeslotsInterval);
+    }
+
+    loadPlugins() {
+        this.pluginsManager = new PluginsManager(this);
+    }
+
+    /**
+     *
+     * @returns {PluginsManager}
+     */
+    getPluginManager() {
+        return this.pluginsManager;
+    }
+
+    /**
+     *
+     * @param {MonitorType} monitorType
+     */
+    addMonitorType(monitorType) {
+        if (monitorType instanceof MonitorType && monitorType.name) {
+            if (monitorType.name in UptimeKumaServer.monitorTypeList) {
+                log.error("", "Conflict Monitor Type name");
+            }
+            UptimeKumaServer.monitorTypeList[monitorType.name] = monitorType;
+        } else {
+            log.error("", "Invalid Monitor Type: " + monitorType.name);
+        }
+    }
+
+    /**
+     *
+     * @param {MonitorType} monitorType
+     */
+    removeMonitorType(monitorType) {
+        if (UptimeKumaServer.monitorTypeList[monitorType.name] === monitorType) {
+            delete UptimeKumaServer.monitorTypeList[monitorType.name];
+        } else {
+            log.error("", "Remove MonitorType failed: " + monitorType.name);
+        }
+    }
+
+}
+
+module.exports = {
+    UptimeKumaServer
+};
+
+// Must be at the end
+const MaintenanceTimeslot = require("./model/maintenance_timeslot");
+const { MonitorType } = require("./monitor-types/monitor-type");

server/util-server.js

@@ -1,21 +1,34 @@
 const tcpp = require("tcp-ping");
-const Ping = require("./ping-lite");
+const ping = require("@louislam/ping");
 const { R } = require("redbean-node");
-const { debug } = require("../src/util");
+const { log, genSecret } = require("../src/util");
 const passwordHash = require("./password-hash");
-const dayjs = require("dayjs");
 const { Resolver } = require("dns");
-const child_process = require("child_process");
+const childProcess = require("child_process");
 const iconv = require("iconv-lite");
 const chardet = require("chardet");
-const fs = require("fs");
-const nodeJsUtil = require("util");
+const mqtt = require("mqtt");
+const chroma = require("chroma-js");
+const { badgeConstants } = require("./config");
+const mssql = require("mssql");
+const { Client } = require("pg");
+const postgresConParse = require("pg-connection-string").parse;
+const mysql = require("mysql2");
+const { MongoClient } = require("mongodb");
+const { NtlmClient } = require("axios-ntlm");
+const { Settings } = require("./settings");
+const grpc = require("@grpc/grpc-js");
+const protojs = require("protobufjs");
+const radiusClient = require("node-radius-client");
+const redis = require("redis");
+const {
+    dictionaries: {
+        rfc2865: { file, attributes },
+    },
+} = require("node-radius-utils");
+const dayjs = require("dayjs");
 
-// From ping-lite
-exports.WIN = /^win/.test(process.platform);
-exports.LIN = /^linux/.test(process.platform);
-exports.MAC = /^darwin/.test(process.platform);
-exports.FBSD = /^freebsd/.test(process.platform);
+const isWindows = process.platform === /^win/.test(process.platform);
 
 /**
  * Init or reset JWT secret
@@ -26,16 +39,22 @@ exports.initJWTSecret = async () => {
         "jwtSecret",
     ]);
 
-    if (! jwtSecretBean) {
+    if (!jwtSecretBean) {
         jwtSecretBean = R.dispense("setting");
         jwtSecretBean.key = "jwtSecret";
     }
 
-    jwtSecretBean.value = passwordHash.generate(dayjs() + "");
+    jwtSecretBean.value = passwordHash.generate(genSecret());
     await R.store(jwtSecretBean);
     return jwtSecretBean;
 };
 
+/**
+ * Send TCP request to specified hostname and port
+ * @param {string} hostname Hostname / address of machine
+ * @param {number} port TCP port to test
+ * @returns {Promise<number>} Maximum time in ms rounded to nearest integer
+ */
 exports.tcping = function (hostname, port) {
     return new Promise((resolve, reject) => {
         tcpp.ping({
@@ -57,42 +76,159 @@ exports.tcping = function (hostname, port) {
     });
 };
 
-exports.ping = async (hostname) => {
+/**
+ * Ping the specified machine
+ * @param {string} hostname Hostname / address of machine
+ * @param {number} [size=56] Size of packet to send
+ * @returns {Promise<number>} Time for ping in ms rounded to nearest integer
+ */
+exports.ping = async (hostname, size = 56) => {
     try {
-        return await exports.pingAsync(hostname);
+        return await exports.pingAsync(hostname, false, size);
     } catch (e) {
         // If the host cannot be resolved, try again with ipv6
         if (e.message.includes("service not known")) {
-            return await exports.pingAsync(hostname, true);
+            return await exports.pingAsync(hostname, true, size);
         } else {
             throw e;
         }
     }
 };
 
-exports.pingAsync = function (hostname, ipv6 = false) {
+/**
+ * Ping the specified machine
+ * @param {string} hostname Hostname / address of machine to ping
+ * @param {boolean} ipv6 Should IPv6 be used?
+ * @param {number} [size = 56] Size of ping packet to send
+ * @returns {Promise<number>} Time for ping in ms rounded to nearest integer
+ */
+exports.pingAsync = function (hostname, ipv6 = false, size = 56) {
     return new Promise((resolve, reject) => {
-        const ping = new Ping(hostname, {
-            ipv6
-        });
-
-        ping.send(function (err, ms, stdout) {
-            if (err) {
-                reject(err);
-            } else if (ms === null) {
-                reject(new Error(stdout));
+        ping.promise.probe(hostname, {
+            v6: ipv6,
+            min_reply: 1,
+            deadline: 10,
+            packetSize: size,
+        }).then((res) => {
+            // If ping failed, it will set field to unknown
+            if (res.alive) {
+                resolve(res.time);
             } else {
-                resolve(Math.round(ms));
+                if (isWindows) {
+                    reject(new Error(exports.convertToUTF8(res.output)));
+                } else {
+                    reject(new Error(res.output));
+                }
             }
+        }).catch((err) => {
+            reject(err);
         });
     });
 };
 
-exports.dnsResolve = function (hostname, resolver_server, rrtype) {
-    const resolver = new Resolver();
-    resolver.setServers([resolver_server]);
+/**
+ * MQTT Monitor
+ * @param {string} hostname Hostname / address of machine to test
+ * @param {string} topic MQTT topic
+ * @param {string} okMessage Expected result
+ * @param {Object} [options={}] MQTT options. Contains port, username,
+ * password and interval (interval defaults to 20)
+ * @returns {Promise<string>}
+ */
+exports.mqttAsync = function (hostname, topic, okMessage, options = {}) {
     return new Promise((resolve, reject) => {
-        if (rrtype == "PTR") {
+        const { port, username, password, interval = 20 } = options;
+
+        // Adds MQTT protocol to the hostname if not already present
+        if (!/^(?:http|mqtt|ws)s?:\/\//.test(hostname)) {
+            hostname = "mqtt://" + hostname;
+        }
+
+        const timeoutID = setTimeout(() => {
+            log.debug("mqtt", "MQTT timeout triggered");
+            client.end();
+            reject(new Error("Timeout"));
+        }, interval * 1000 * 0.8);
+
+        const mqttUrl = `${hostname}:${port}`;
+
+        log.debug("mqtt", `MQTT connecting to ${mqttUrl}`);
+
+        let client = mqtt.connect(mqttUrl, {
+            username,
+            password
+        });
+
+        client.on("connect", () => {
+            log.debug("mqtt", "MQTT connected");
+
+            try {
+                log.debug("mqtt", "MQTT subscribe topic");
+                client.subscribe(topic);
+            } catch (e) {
+                client.end();
+                clearTimeout(timeoutID);
+                reject(new Error("Cannot subscribe topic"));
+            }
+        });
+
+        client.on("error", (error) => {
+            client.end();
+            clearTimeout(timeoutID);
+            reject(error);
+        });
+
+        client.on("message", (messageTopic, message) => {
+            if (messageTopic === topic) {
+                client.end();
+                clearTimeout(timeoutID);
+                if (okMessage != null && okMessage !== "" && message.toString() !== okMessage) {
+                    reject(new Error(`Message Mismatch - Topic: ${messageTopic}; Message: ${message.toString()}`));
+                } else {
+                    resolve(`Topic: ${messageTopic}; Message: ${message.toString()}`);
+                }
+            }
+        });
+
+    });
+};
+
+/**
+ * Use NTLM Auth for a http request.
+ * @param {Object} options The http request options
+ * @param {Object} ntlmOptions The auth options
+ * @returns {Promise<(string[]|Object[]|Object)>}
+ */
+exports.httpNtlm = function (options, ntlmOptions) {
+    return new Promise((resolve, reject) => {
+        let client = NtlmClient(ntlmOptions);
+
+        client(options)
+            .then((resp) => {
+                resolve(resp);
+            })
+            .catch((err) => {
+                reject(err);
+            });
+    });
+};
+
+/**
+ * Resolves a given record using the specified DNS server
+ * @param {string} hostname The hostname of the record to lookup
+ * @param {string} resolverServer The DNS server to use
+ * @param {string} resolverPort Port the DNS server is listening on
+ * @param {string} rrtype The type of record to request
+ * @returns {Promise<(string[]|Object[]|Object)>}
+ */
+exports.dnsResolve = function (hostname, resolverServer, resolverPort, rrtype) {
+    const resolver = new Resolver();
+    // Remove brackets from IPv6 addresses so we can re-add them to
+    // prevent issues with ::1:5300 (::1 port 5300)
+    resolverServer = resolverServer.replace("[", "").replace("]", "");
+    resolver.setServers([ `[${resolverServer}]:${resolverPort}` ]);
+    return new Promise((resolve, reject) => {
+        if (rrtype === "PTR") {
             resolver.reverse(hostname, (err, records) => {
                 if (err) {
                     reject(err);
@@ -112,83 +248,231 @@ exports.dnsResolve = function (hostname, resolver_server, rrtype) {
     });
 };
 
-exports.setting = async function (key) {
-    let value = await R.getCell("SELECT `value` FROM setting WHERE `key` = ? ", [
-        key,
-    ]);
-
+/**
+ * Run a query on SQL Server
+ * @param {string} connectionString The database connection string
+ * @param {string} query The query to validate the database with
+ * @returns {Promise<(string[]|Object[]|Object)>}
+ */
+exports.mssqlQuery = async function (connectionString, query) {
+    let pool;
     try {
-        const v = JSON.parse(value);
-        debug(`Get Setting: ${key}: ${v}`);
-        return v;
+        pool = new mssql.ConnectionPool(connectionString);
+        await pool.connect();
+        await pool.request().query(query);
+        pool.close();
     } catch (e) {
-        return value;
+        if (pool) {
+            pool.close();
+        }
+        throw e;
     }
 };
 
+/**
+ * Run a query on Postgres
+ * @param {string} connectionString The database connection string
+ * @param {string} query The query to validate the database with
+ * @returns {Promise<(string[]|Object[]|Object)>}
+ */
+exports.postgresQuery = function (connectionString, query) {
+    return new Promise((resolve, reject) => {
+        const config = postgresConParse(connectionString);
+
+        if (config.password === "") {
+            // See https://github.com/brianc/node-postgres/issues/1927
+            return reject(new Error("Password is undefined."));
+        }
+
+        const client = new Client({ connectionString });
+
+        client.connect((err) => {
+            if (err) {
+                reject(err);
+                client.end();
+            } else {
+                // Connected here
+                try {
+                    // No query provided by user, use SELECT 1
+                    if (!query || (typeof query === "string" && query.trim() === "")) {
+                        query = "SELECT 1";
+                    }
+
+                    client.query(query, (err, res) => {
+                        if (err) {
+                            reject(err);
+                        } else {
+                            resolve(res);
+                        }
+                        client.end();
+                    });
+                } catch (e) {
+                    reject(e);
+                }
+            }
+        });
+
+    });
+};
+
+/**
+ * Run a query on MySQL/MariaDB
+ * @param {string} connectionString The database connection string
+ * @param {string} query The query to validate the database with
+ * @returns {Promise<(string[]|Object[]|Object)>}
+ */
+exports.mysqlQuery = function (connectionString, query) {
+    return new Promise((resolve, reject) => {
+        const connection = mysql.createConnection(connectionString);
+        connection.promise().query(query)
+            .then(res => {
+                resolve(res);
+            })
+            .catch(err => {
+                reject(err);
+            })
+            .finally(() => {
+                connection.destroy();
+            });
+    });
+};
+
+/**
+ * Connect to and Ping a MongoDB database
+ * @param {string} connectionString The database connection string
+ * @returns {Promise<(string[]|Object[]|Object)>}
+ */
+exports.mongodbPing = async function (connectionString) {
+    let client = await MongoClient.connect(connectionString);
+    let dbPing = await client.db().command({ ping: 1 });
+    await client.close();
+
+    if (dbPing["ok"] === 1) {
+        return "UP";
+    } else {
+        throw Error("failed");
+    }
+};
+
+/**
+ * Query radius server
+ * @param {string} hostname Hostname of radius server
+ * @param {string} username Username to use
+ * @param {string} password Password to use
+ * @param {string} calledStationId ID of called station
+ * @param {string} callingStationId ID of calling station
+ * @param {string} secret Secret to use
+ * @param {number} [port=1812] Port to contact radius server on
+ * @returns {Promise<any>}
+ */
+exports.radius = function (
+    hostname,
+    username,
+    password,
+    calledStationId,
+    callingStationId,
+    secret,
+    port = 1812,
+) {
+    const client = new radiusClient({
+        host: hostname,
+        hostPort: port,
+        dictionaries: [ file ],
+    });
+
+    return client.accessRequest({
+        secret: secret,
+        attributes: [
+            [ attributes.USER_NAME, username ],
+            [ attributes.USER_PASSWORD, password ],
+            [ attributes.CALLING_STATION_ID, callingStationId ],
+            [ attributes.CALLED_STATION_ID, calledStationId ],
+        ],
+    });
+};
+
+/**
+ * Redis server ping
+ * @param {string} dsn The redis connection string
+ */
+exports.redisPingAsync = function (dsn) {
+    return new Promise((resolve, reject) => {
+        const client = redis.createClient({
+            url: dsn,
+        });
+        client.on("error", (err) => {
+            reject(err);
+        });
+        client.connect().then(() => {
+            client.ping().then((res, err) => {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(res);
+                }
+            });
+        });
+    });
+};
+
+/**
+ * Retrieve value of setting based on key
+ * @param {string} key Key of setting to retrieve
+ * @returns {Promise<any>} Value
+ * @deprecated Use await Settings.get(key)
+ */
+exports.setting = async function (key) {
+    return await Settings.get(key);
+};
+
+/**
+ * Sets the specified setting to specifed value
+ * @param {string} key Key of setting to set
+ * @param {any} value Value to set to
+ * @param {?string} type Type of setting
+ * @returns {Promise<void>}
+ */
 exports.setSetting = async function (key, value, type = null) {
-    let bean = await R.findOne("setting", " `key` = ? ", [
-        key,
-    ]);
-    if (!bean) {
-        bean = R.dispense("setting");
-        bean.key = key;
-    }
-    bean.type = type;
-    bean.value = JSON.stringify(value);
-    await R.store(bean);
+    await Settings.set(key, value, type);
 };
 
+/**
+ * Get settings based on type
+ * @param {string} type The type of setting
+ * @returns {Promise<Bean>}
+ */
 exports.getSettings = async function (type) {
-    let list = await R.getAll("SELECT `key`, `value` FROM setting WHERE `type` = ? ", [
-        type,
-    ]);
-
-    let result = {};
-
-    for (let row of list) {
-        try {
-            result[row.key] = JSON.parse(row.value);
-        } catch (e) {
-            result[row.key] = row.value;
-        }
-    }
-
-    return result;
+    return await Settings.getSettings(type);
 };
 
+/**
+ * Set settings based on type
+ * @param {string} type Type of settings to set
+ * @param {Object} data Values of settings
+ * @returns {Promise<void>}
+ */
 exports.setSettings = async function (type, data) {
-    let keyList = Object.keys(data);
-
-    let promiseList = [];
-
-    for (let key of keyList) {
-        let bean = await R.findOne("setting", " `key` = ? ", [
-            key
-        ]);
-
-        if (bean == null) {
-            bean = R.dispense("setting");
-            bean.type = type;
-            bean.key = key;
-        }
-
-        if (bean.type === type) {
-            bean.value = JSON.stringify(data[key]);
-            promiseList.push(R.store(bean));
-        }
-    }
-
-    await Promise.all(promiseList);
+    await Settings.setSettings(type, data);
 };
 
 // ssl-checker by @dyaa
-// param: res - response object from axios
-// return an object containing the certificate information
+//https://github.com/dyaa/ssl-checker/blob/master/src/index.ts
 
+/**
+ * Get number of days between two dates
+ * @param {Date} validFrom Start date
+ * @param {Date} validTo End date
+ * @returns {number}
+ */
 const getDaysBetween = (validFrom, validTo) =>
     Math.round(Math.abs(+validFrom - +validTo) / 8.64e7);
 
+/**
+ * Get days remaining from a time range
+ * @param {Date} validFrom Start date
+ * @param {Date} validTo End date
+ * @returns {number}
+ */
 const getDaysRemaining = (validFrom, validTo) => {
     const daysRemaining = getDaysBetween(validFrom, validTo);
     if (new Date(validTo).getTime() < new Date().getTime()) {
@@ -197,8 +481,11 @@ const getDaysRemaining = (validFrom, validTo) => {
     return daysRemaining;
 };
 
-// Fix certificate Info for display
-// param: info -  the chain obtained from getPeerCertificate()
+/**
+ * Fix certificate info for display
+ * @param {Object} info The chain obtained from getPeerCertificate()
+ * @returns {Object} An object representing certificate information
+ */
 const parseCertificateInfo = function (info) {
     let link = info;
     let i = 0;
@@ -206,7 +493,7 @@ const parseCertificateInfo = function (info) {
     const existingList = {};
 
     while (link) {
-        debug(`[${i}] ${link.fingerprint}`);
+        log.debug("cert", `[${i}] ${link.fingerprint}`);
 
         if (!link.valid_from || !link.valid_to) {
             break;
@@ -221,7 +508,7 @@ const parseCertificateInfo = function (info) {
         if (link.issuerCertificate == null) {
             break;
         } else if (link.issuerCertificate.fingerprint in existingList) {
-            debug(`[Last] ${link.issuerCertificate.fingerprint}`);
+            log.debug("cert", `[Last] ${link.issuerCertificate.fingerprint}`);
             link.issuerCertificate = null;
             break;
         } else {
@@ -238,11 +525,20 @@ const parseCertificateInfo = function (info) {
     return info;
 };
 
+/**
+ * Check if certificate is valid
+ * @param {Object} res Response object from axios
+ * @returns {Object} Object containing certificate information
+ */
 exports.checkCertificate = function (res) {
+    if (!res.request.res.socket) {
+        throw new Error("No socket found");
+    }
+
     const info = res.request.res.socket.getPeerCertificate(true);
     const valid = res.request.res.socket.authorized || false;
 
-    debug("Parsing Certificate Info");
+    log.debug("cert", "Parsing Certificate Info");
     const parsedInfo = parseCertificateInfo(info);
 
     return {
@@ -251,25 +547,26 @@ exports.checkCertificate = function (res) {
     };
 };
 
-// Check if the provided status code is within the accepted ranges
-// Param: status - the status code to check
-// Param: accepted_codes - an array of accepted status codes
-// Return: true if the status code is within the accepted ranges, false otherwise
-// Will throw an error if the provided status code is not a valid range string or code string
-
-exports.checkStatusCode = function (status, accepted_codes) {
-    if (accepted_codes == null || accepted_codes.length === 0) {
+/**
+ * Check if the provided status code is within the accepted ranges
+ * @param {number} status The status code to check
+ * @param {string[]} acceptedCodes An array of accepted status codes
+ * @returns {boolean} True if status code within range, false otherwise
+ * @throws {Error} Will throw an error if the provided status code is not a valid range string or code string
+ */
+exports.checkStatusCode = function (status, acceptedCodes) {
+    if (acceptedCodes == null || acceptedCodes.length === 0) {
         return false;
     }
 
-    for (const code_range of accepted_codes) {
-        const code_range_split = code_range.split("-").map(string => parseInt(string));
-        if (code_range_split.length === 1) {
-            if (status === code_range_split[0]) {
+    for (const codeRange of acceptedCodes) {
+        const codeRangeSplit = codeRange.split("-").map(string => parseInt(string));
+        if (codeRangeSplit.length === 1) {
+            if (status === codeRangeSplit[0]) {
                 return true;
             }
-        } else if (code_range_split.length === 2) {
-            if (status >= code_range_split[0] && status <= code_range_split[1]) {
+        } else if (codeRangeSplit.length === 2) {
+            if (status >= codeRangeSplit[0] && status <= codeRangeSplit[1]) {
                 return true;
             }
         } else {
@@ -280,17 +577,23 @@ exports.checkStatusCode = function (status, accepted_codes) {
     return false;
 };
 
+/**
+ * Get total number of clients in room
+ * @param {Server} io Socket server instance
+ * @param {string} roomName Name of room to check
+ * @returns {number}
+ */
 exports.getTotalClientInRoom = (io, roomName) => {
 
     const sockets = io.sockets;
 
-    if (! sockets) {
+    if (!sockets) {
         return 0;
     }
 
     const adapter = sockets.adapter;
 
-    if (! adapter) {
+    if (!adapter) {
         return 0;
     }
 
@@ -303,27 +606,82 @@ exports.getTotalClientInRoom = (io, roomName) => {
     }
 };
 
+/**
+ * Allow CORS all origins if development
+ * @param {Object} res Response object from axios
+ */
 exports.allowDevAllOrigin = (res) => {
     if (process.env.NODE_ENV === "development") {
         exports.allowAllOrigin(res);
     }
 };
 
+/**
+ * Allow CORS all origins
+ * @param {Object} res Response object from axios
+ */
 exports.allowAllOrigin = (res) => {
     res.header("Access-Control-Allow-Origin", "*");
     res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
 };
 
+/**
+ * Check if a user is logged in
+ * @param {Socket} socket Socket instance
+ */
 exports.checkLogin = (socket) => {
-    if (! socket.userID) {
+    if (!socket.userID) {
         throw new Error("You are not logged in.");
     }
 };
 
+/**
+ * For logged-in users, double-check the password
+ * @param {Socket} socket Socket.io instance
+ * @param {string} currentPassword
+ * @returns {Promise<Bean>}
+ */
+exports.doubleCheckPassword = async (socket, currentPassword) => {
+    if (typeof currentPassword !== "string") {
+        throw new Error("Wrong data type?");
+    }
+
+    let user = await R.findOne("user", " id = ? AND active = 1 ", [
+        socket.userID,
+    ]);
+
+    if (!user || !passwordHash.verify(currentPassword, user.password)) {
+        throw new Error("Incorrect current password");
+    }
+
+    return user;
+};
+
+/** Start Unit tests */
 exports.startUnitTest = async () => {
     console.log("Starting unit test...");
     const npm = /^win/.test(process.platform) ? "npm.cmd" : "npm";
-    const child = child_process.spawn(npm, ["run", "jest"]);
+    const child = childProcess.spawn(npm, [ "run", "jest-backend" ]);
+
+    child.stdout.on("data", (data) => {
+        console.log(data.toString());
+    });
+
+    child.stderr.on("data", (data) => {
+        console.log(data.toString());
+    });
+
+    child.on("close", function (code) {
+        console.log("Jest exit code: " + code);
+        process.exit(code);
+    });
+};
+
+/** Start end-to-end tests */
+exports.startE2eTests = async () => {
+    console.log("Starting unit test...");
+    const npm = /^win/.test(process.platform) ? "npm.cmd" : "npm";
+    const child = childProcess.spawn(npm, [ "run", "cy:run" ]);
 
     child.stdout.on("data", (data) => {
         console.log(data.toString());
@@ -340,33 +698,184 @@ exports.startUnitTest = async () => {
 };
 
 /**
- * @param body : Buffer
+ * Convert unknown string to UTF8
+ * @param {Uint8Array} body Buffer
  * @returns {string}
  */
 exports.convertToUTF8 = (body) => {
     const guessEncoding = chardet.detect(body);
-    //debug("Guess Encoding: " + guessEncoding);
     const str = iconv.decode(body, guessEncoding);
     return str.toString();
 };
 
-let logFile;
-
-try {
-    logFile = fs.createWriteStream("./data/error.log", {
-        flags: "a"
-    });
-} catch (_) { }
-
-exports.errorLog = (error, outputToConsole = true) => {
+/**
+ * Returns a color code in hex format based on a given percentage:
+ * 0% => hue = 10 => red
+ * 100% => hue = 90 => green
+ *
+ * @param {number} percentage float, 0 to 1
+ * @param {number} maxHue
+ * @param {number} minHue, int
+ * @returns {string}, hex value
+ */
+exports.percentageToColor = (percentage, maxHue = 90, minHue = 10) => {
+    const hue = percentage * (maxHue - minHue) + minHue;
     try {
-        if (logFile) {
-            const dateTime = R.isoDateTime();
-            logFile.write(`[${dateTime}] ` + nodeJsUtil.format(error) + "\n");
-
-            if (outputToConsole) {
-                console.error(error);
-            }
-        }
-    } catch (_) { }
+        return chroma(`hsl(${hue}, 90%, 40%)`).hex();
+    } catch (err) {
+        return badgeConstants.naColor;
+    }
+};
+
+/**
+ * Joins and array of string to one string after filtering out empty values
+ *
+ * @param {string[]} parts
+ * @param {string} connector
+ * @returns {string}
+ */
+exports.filterAndJoin = (parts, connector = "") => {
+    return parts.filter((part) => !!part && part !== "").join(connector);
+};
+
+/**
+ * Send an Error response
+ * @param {Object} res Express response object
+ * @param {string} [msg=""] Message to send
+ */
+module.exports.sendHttpError = (res, msg = "") => {
+    if (msg.includes("SQLITE_BUSY") || msg.includes("SQLITE_LOCKED")) {
+        res.status(503).json({
+            "status": "fail",
+            "msg": msg,
+        });
+    } else if (msg.toLowerCase().includes("not found")) {
+        res.status(404).json({
+            "status": "fail",
+            "msg": msg,
+        });
+    } else {
+        res.status(403).json({
+            "status": "fail",
+            "msg": msg,
+        });
+    }
+};
+
+function timeObjectConvertTimezone(obj, timezone, timeObjectToUTC = true) {
+    let offsetString;
+
+    if (timezone) {
+        offsetString = dayjs().tz(timezone).format("Z");
+    } else {
+        offsetString = dayjs().format("Z");
+    }
+
+    let hours = parseInt(offsetString.substring(1, 3));
+    let minutes = parseInt(offsetString.substring(4, 6));
+
+    if (
+        (timeObjectToUTC && offsetString.startsWith("+")) ||
+        (!timeObjectToUTC && offsetString.startsWith("-"))
+    ) {
+        hours *= -1;
+        minutes *= -1;
+    }
+
+    obj.hours += hours;
+    obj.minutes += minutes;
+
+    // Handle out of bound
+    if (obj.minutes < 0) {
+        obj.minutes += 60;
+        obj.hours--;
+    } else if (obj.minutes > 60) {
+        obj.minutes -= 60;
+        obj.hours++;
+    }
+
+    if (obj.hours < 0) {
+        obj.hours += 24;
+    } else if (obj.hours > 24) {
+        obj.hours -= 24;
+    }
+
+    return obj;
+}
+
+/**
+ *
+ * @param {object} obj
+ * @param {string} timezone
+ * @returns {object}
+ */
+module.exports.timeObjectToUTC = (obj, timezone = undefined) => {
+    return timeObjectConvertTimezone(obj, timezone, true);
+};
+
+/**
+ *
+ * @param {object} obj
+ * @param {string} timezone
+ * @returns {object}
+ */
+module.exports.timeObjectToLocal = (obj, timezone = undefined) => {
+    return timeObjectConvertTimezone(obj, timezone, false);
+};
+
+/**
+ * Create gRPC client stib
+ * @param {Object} options from gRPC client
+ */
+module.exports.grpcQuery = async (options) => {
+    const { grpcUrl, grpcProtobufData, grpcServiceName, grpcEnableTls, grpcMethod, grpcBody } = options;
+    const protocObject = protojs.parse(grpcProtobufData);
+    const protoServiceObject = protocObject.root.lookupService(grpcServiceName);
+    const Client = grpc.makeGenericClientConstructor({});
+    const credentials = grpcEnableTls ? grpc.credentials.createSsl() : grpc.credentials.createInsecure();
+    const client = new Client(
+        grpcUrl,
+        credentials
+    );
+    const grpcService = protoServiceObject.create(function (method, requestData, cb) {
+        const fullServiceName = method.fullName;
+        const serviceFQDN = fullServiceName.split(".");
+        const serviceMethod = serviceFQDN.pop();
+        const serviceMethodClientImpl = `/${serviceFQDN.slice(1).join(".")}/${serviceMethod}`;
+        log.debug("monitor", `gRPC method ${serviceMethodClientImpl}`);
+        client.makeUnaryRequest(
+            serviceMethodClientImpl,
+            arg => arg,
+            arg => arg,
+            requestData,
+            cb);
+    }, false, false);
+    return new Promise((resolve, _) => {
+        try {
+            return grpcService[`${grpcMethod}`](JSON.parse(grpcBody), function (err, response) {
+                const responseData = JSON.stringify(response);
+                if (err) {
+                    return resolve({
+                        code: err.code,
+                        errorMessage: err.details,
+                        data: ""
+                    });
+                } else {
+                    log.debug("monitor:", `gRPC response: ${JSON.stringify(response)}`);
+                    return resolve({
+                        code: 1,
+                        errorMessage: "",
+                        data: responseData
+                    });
+                }
+            });
+        } catch (err) {
+            return resolve({
+                code: -1,
+                errorMessage: `Error ${err}. Please review your gRPC configuration option. The service name must not include package name value, and the method name must follow camelCase format`,
+                data: ""
+            });
+        }
+
+    });
 };