Add Discord webhook notification support

Server/db/models/Notification.js

@@ -8,7 +8,7 @@ const NotificationSchema = mongoose.Schema(
 		},
 		type: {
 			type: String,
-			enum: ["email", "sms"],
+			enum: ["email", "sms", "discord", "slack", "telegram"],
 		},
 		address: {
 			type: String,

Server/index.js

@@ -38,6 +38,10 @@ import QueueController from "./controllers/queueController.js";
 import DistributedUptimeRoutes from "./routes/distributedUptimeRoute.js";
 import DistributedUptimeController from "./controllers/distributedUptimeController.js";
 
+import NotificationRoutes from "./routes/notificationRoute.js"; // Add this line
+
+import NotificationController from "./controllers/notificationController.js";
+
 //JobQueue service and dependencies
 import JobQueue from "./service/jobQueue.js";
 import { Queue, Worker } from "bullmq";
@@ -174,7 +178,7 @@ const startApp = async () => {
 	);
 	const networkService = new NetworkService(axios, ping, logger, http, Docker, net);
 	const statusService = new StatusService(db, logger);
-	const notificationService = new NotificationService(emailService, db, logger);
+	const notificationService = new NotificationService(emailService, db, logger, networkService);
 
 	const jobQueue = new JobQueue(
 		db,
@@ -244,6 +248,10 @@ const startApp = async () => {
 		ServiceRegistry.get(MongoDB.SERVICE_NAME)
 	);
 
+	const notificationController = new NotificationController(
+		ServiceRegistry.get(NotificationService.SERVICE_NAME)
+	);
+
 	const distributedUptimeController = new DistributedUptimeController();
 
 	//Create routes
@@ -260,6 +268,9 @@ const startApp = async () => {
 	const distributedUptimeRoutes = new DistributedUptimeRoutes(
 		distributedUptimeController
 	);
+
+	const notificationRoutes = new NotificationRoutes(notificationController);
+
 	// Init job queue
 	await jobQueue.initJobQueue();
 	// Middleware
@@ -284,6 +295,7 @@ const startApp = async () => {
 	app.use("/api/v1/queue", verifyJWT, queueRoutes.getRouter());
 	app.use("/api/v1/distributed-uptime", distributedUptimeRoutes.getRouter());
 	app.use("/api/v1/status-page", statusPageRoutes.getRouter());
+	app.use("/api/v1/notifications", notificationRoutes.getRouter()); // Add this line
 	app.use(handleErrors);
 };
 

Server/service/networkService.js

@@ -336,6 +336,52 @@ class NetworkService {
 		throw err;
 	}
 
+	async requestWebhook(platform, url, message) {
+		try {
+			const { response, responseTime, error } = await this.timeRequest(() =>
+				this.axios.post(url, message, {
+					headers: {
+						'Content-Type': 'application/json'
+					}
+				})
+			);
+
+			const webhookResponse = {
+				type: 'webhook',
+				responseTime,
+				payload: response?.data
+			};
+
+			if (error) {
+				webhookResponse.status = false;
+				webhookResponse.code = error.response?.status || this.NETWORK_ERROR;
+				webhookResponse.message = `Failed to send ${platform} notification`;
+				this.logger.warn({
+					message: error.message,
+					service: this.SERVICE_NAME,
+					method: 'requestWebhook',
+					url,
+					platform,
+					error: error.message,
+					statusCode: error.response?.status,
+					responseData: error.response?.data,
+					requestPayload: message
+				});
+				return webhookResponse;
+			}
+
+			webhookResponse.status = true;
+			webhookResponse.code = response.status;
+			webhookResponse.message = `Successfully sent ${platform} notification`;
+			return webhookResponse;
+		} catch (error) {
+			error.service = this.SERVICE_NAME;
+			error.method = 'requestWebhook';
+			throw error;
+		}
+	}
+
+
 	/**
 	 * Gets the status of a job based on its type and returns the appropriate response.
 	 *

Server/service/notificationService.js

@@ -1,4 +1,6 @@
 const SERVICE_NAME = "NotificationService";
+import NetworkService from "./networkService.js";
+
 
 class NotificationService {
 	static SERVICE_NAME = SERVICE_NAME;
@@ -9,13 +11,55 @@ class NotificationService {
 	 * @param {Object} db - The database instance for storing notification data.
 	 * @param {Object} logger - The logger instance for logging activities.
 	 */
-	constructor(emailService, db, logger) {
+	constructor(emailService, db, logger, networkService) {
 		this.SERVICE_NAME = SERVICE_NAME;
 		this.emailService = emailService;
 		this.db = db;
 		this.logger = logger;
+		this.networkService = networkService;
 	}
 
+	async sendWebhookNotification(networkResponse, address, platform) {
+		const { monitor, status } = networkResponse;
+		let message;
+		let url = address;
+
+		if (platform === 'slack') {
+			message = { text: `Monitor ${monitor.name} is ${status ? "up" : "down"}. URL: ${monitor.url}` };
+		} else if (platform === 'discord') {
+			message = { content: `Monitor ${monitor.name} is ${status ? "up" : "down"}. URL: ${monitor.url}` };
+		} else if (platform === 'telegram') {
+			const [botToken, chatId] = address.split('|').map(part => part?.trim());
+			if (!botToken || !chatId) {
+				return false;
+			}
+			message = {
+				chat_id: chatId,
+				text: `Monitor ${monitor.name} is ${status ? "up" : "down"}. URL: ${monitor.url}`
+			};
+			url = `https://api.telegram.org/bot${botToken}/sendMessage`;
+		}
+
+		try {
+			const response = await this.networkService.requestWebhook(platform, url, message);
+			return response.status;
+		} catch (error) {
+			this.logger.error({
+				message: `Error sending ${platform} notification`,
+				service: this.SERVICE_NAME,
+				method: 'sendWebhookNotification',
+				error: error.message,
+				stack: error.stack,
+				url,
+				platform,
+				requestPayload: message
+			});
+			return false;
+		}
+	}
+
+
+
 	/**
 	 * Sends an email notification for hardware infrastructure alerts
 	 *
@@ -57,21 +101,20 @@ class NotificationService {
 
 	async handleStatusNotifications(networkResponse) {
 		try {
-			//If status hasn't changed, we're done
 			if (networkResponse.statusChanged === false) return false;
-
-			// if prevStatus is undefined, monitor is resuming, we're done
 			if (networkResponse.prevStatus === undefined) return false;
-			const notifications = await this.db.getNotificationsByMonitorId(
-				networkResponse.monitorId
-			);
-
+
+			const notifications = await this.db.getNotificationsByMonitorId(networkResponse.monitorId);
+
 			for (const notification of notifications) {
 				if (notification.type === "email") {
 					this.sendEmail(networkResponse, notification.address);
-				}
+				} else if (["discord", "slack", "telegram"].includes(notification.type)) {
+					this.sendWebhookNotification(networkResponse, notification.address, notification.type);
+
 				// Handle other types of notifications here
 			}
+		}
 			return true;
 		} catch (error) {
 			this.logger.warn({