Add Discord webhook notification support

Server/controllers/notificationController.js

@@ -0,0 +1,37 @@
+import logger from '../utils/logger.js';
+
+class NotificationController {
+    constructor(notificationService) {
+        this.notificationService = notificationService;
+    }
+
+    async triggerNotification(req, res) {
+        try {
+            const { monitorId, type, config } = req.body;
+
+            const networkResponse = {
+                monitor: { _id: monitorId, name: "Test Monitor", url: "http://www.google.com" },
+                status: false,
+                statusChanged: true,
+                prevStatus: true,
+            };
+            if (type === "webhook") {
+                await this.notificationService.sendWebhookNotification(
+                    networkResponse,
+                    config
+                );
+            }
+            res.json({ success: true, msg: "Notification sent successfully" });
+        } catch (error) {
+            logger.error({
+                message: error.message,
+                service: "NotificationController",
+                method: "triggerNotification",
+                stack: error.stack,
+            });
+            res.status(500).json({ success: false, msg: "Failed to send notification" });
+        }
+    }
+}
+
+export default NotificationController;

Server/db/models/Notification.js

@@ -8,8 +8,14 @@ const NotificationSchema = mongoose.Schema(
 		},
 		type: {
 			type: String,
-			enum: ["email", "sms"],
+			enum: ["email", "sms", "webhook"],
 		},
+		config: {
+			type: String,  
+			webhookUrl: String,
+			botToken: String,
+			chatId: String
+		  },
 		address: {
 			type: String,
 		},
@@ -76,4 +82,5 @@ NotificationSchema.pre("findOneAndUpdate", function (next) {
 	}
 	next();
 });
+
 export default mongoose.model("Notification", NotificationSchema);

Server/index.js

@@ -38,6 +38,10 @@
 import DistributedUptimeRoutes from "./routes/distributedUptimeRoute.js";
 import DistributedUptimeController from "./controllers/distributedUptimeController.js";
 
+import NotificationRoutes from "./routes/notificationRoute.js";
+
+import NotificationController from "./controllers/notificationController.js";
+
 //JobQueue service and dependencies
 import JobQueue from "./service/jobQueue.js";
 import { Queue, Worker } from "bullmq";
@@ -183,7 +187,7 @@
 		logger
 	);
 	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(
@@ -269,6 +273,10 @@
 		ServiceRegistry.get(StringService.SERVICE_NAME)
 	);
 
+	const notificationController = new NotificationController(
+		ServiceRegistry.get(NotificationService.SERVICE_NAME)
+	);
+
 	const distributedUptimeController = new DistributedUptimeController(
 		ServiceRegistry.get(MongoDB.SERVICE_NAME),
 		http,
@@ -289,6 +297,9 @@
 	const distributedUptimeRoutes = new DistributedUptimeRoutes(
 		distributedUptimeController
 	);
+
+	const notificationRoutes = new NotificationRoutes(notificationController);
+
 	// Init job queue
 	await jobQueue.initJobQueue();
 	// Middleware
@@ -311,6 +322,7 @@
 	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", verifyJWT, notificationRoutes.getRouter());
 	app.use(handleErrors);
 };
 

Server/routes/notificationRoute.js

@@ -0,0 +1,48 @@
+import express from 'express';
+import { verifyJWT } from '../middleware/verifyJWT.js';
+import { triggerNotificationBodyValidation } from '../validation/joi.js';
+
+class NotificationRoutes {
+    constructor(notificationController) {
+        this.notificationController = notificationController;
+        this.router = express.Router();
+        this.initializeRoutes();
+    }
+
+    validateRequest(schema) {
+        return (req, res, next) => {
+            const { error } = schema.validate(req.body, {
+                abortEarly: false,
+                stripUnknown: true
+            });
+
+            if (error) {
+                const errorMessage = error.details
+                    .map(detail => detail.message)
+                    .join(', ');
+
+                return res.status(400).json({
+                    success: false,
+                    msg: errorMessage
+                });
+            }
+
+            next();
+        };
+    }
+
+    initializeRoutes() {
+        this.router.post(
+            '/trigger', 
+            verifyJWT,
+            this.validateRequest(triggerNotificationBodyValidation),
+            this.notificationController.triggerNotification.bind(this.notificationController)
+        );
+    }
+
+    getRouter() {
+        return this.router;
+    }
+}
+
+export default NotificationRoutes;

Server/service/networkService.js

@@ -418,6 +418,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,5 @@
 const SERVICE_NAME = "NotificationService";
+const TELEGRAM_API_BASE_URL = "https://api.telegram.org/bot";
 
 class NotificationService {
 	static SERVICE_NAME = SERVICE_NAME;
@@ -9,13 +10,70 @@ 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;
 	}
 
+	formatNotificationMessage(monitor, status, platform, chatId) {
+		const messageText = `Monitor ${monitor.name} is ${status ? "up" : "down"}. URL: ${monitor.url}`;
+
+		if (platform === 'telegram') {
+			return { chat_id: chatId, text: messageText };
+		}
+		if (platform === 'slack') {
+			return { text: messageText };
+		}
+		if (platform === 'discord') {
+			return { content: messageText };
+		}
+		return null;
+	}
+
+	async sendWebhookNotification(networkResponse, config) {
+		const { monitor, status } = networkResponse;
+		const { type, webhookUrl, botToken, chatId } = config;
+		let url = webhookUrl;
+
+		const message = this.formatNotificationMessage(monitor, status, type, chatId);
+		if (message === null) {
+			this.logger.warn({
+				message: `Unsupported webhook type: ${type}`,
+				service: this.SERVICE_NAME,
+				method: 'sendWebhookNotification',
+				type
+			});
+			return false;
+		}
+
+		if (type === 'telegram') {
+			if (!botToken || !chatId) {
+				return false;
+			}
+			url = `${TELEGRAM_API_BASE_URL}${botToken}/sendMessage`;
+		}
+
+		try {
+			const response = await this.networkService.requestWebhook(type, url, message);
+			return response.status;
+		} catch (error) {
+			this.logger.error({
+				message: `Error sending ${type} notification`,
+				service: this.SERVICE_NAME,
+				method: 'sendWebhookNotification',
+				error: error.message,
+				stack: error.stack,
+				url,
+				type,
+				requestPayload: message
+			});
+			return false;
+		}
+	}
+
 	/**
 	 * Sends an email notification for hardware infrastructure alerts
 	 *
@@ -59,19 +117,20 @@ class NotificationService {
 		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 (notification.type === "webhook") {
+					this.sendWebhookNotification(networkResponse, notification.address, notification.type);
+
 				// Handle other types of notifications here
 			}
+		}
 			return true;
 		} catch (error) {
 			this.logger.warn({

Server/validation/joi.js

@@ -475,6 +475,59 @@ const imageValidation = joi
 		"any.required": "Image file is required",
 	});
 
+	const telegramWebhookConfigValidation = joi.object({
+		type: joi.string().valid('telegram').required(),
+		botToken: joi.string().required().messages({
+			'string.empty': 'Telegram bot token is required',
+			'any.required': 'Telegram bot token is required'
+		}),
+		chatId: joi.string().required().messages({
+			'string.empty': 'Telegram chat ID is required',
+			'any.required': 'Telegram chat ID is required'
+		})
+	});
+
+	const discordWebhookConfigValidation = joi.object({
+		type: joi.string().valid('discord').required(),
+		webhookUrl: joi.string().uri().required().messages({
+			'string.empty': 'Discord webhook URL is required',
+			'string.uri': 'Discord webhook URL must be a valid URL',
+			'any.required': 'Discord webhook URL is required'
+		})
+	});
+
+	const slackWebhookConfigValidation = joi.object({
+		type: joi.string().valid('slack').required(),
+		webhookUrl: joi.string().uri().required().messages({
+			'string.empty': 'Slack webhook URL is required',
+			'string.uri': 'Slack webhook URL must be a valid URL',
+			'any.required': 'Slack webhook URL is required'
+		})
+	});
+
+	const triggerNotificationBodyValidation = joi.object({
+		monitorId: joi.string().required().messages({
+			'string.empty': 'Monitor ID is required',
+			'any.required': 'Monitor ID is required'
+		}),
+		type: joi.string().valid('webhook').required().messages({
+			'string.empty': 'Notification type is required',
+			'any.required': 'Notification type is required',
+			'any.only': 'Notification type must be webhook'
+		}),
+		config: joi.alternatives()
+			.conditional('type', {
+				is: 'webhook',
+				then: joi.alternatives().try(
+					telegramWebhookConfigValidation,
+					discordWebhookConfigValidation,
+					slackWebhookConfigValidation
+				).required().messages({
+					'any.required': 'Webhook configuration is required'
+				})
+			})
+	});
+
 export {
 	roleValidatior,
 	loginValidation,
@@ -533,5 +586,9 @@ export {
 	createStatusPageBodyValidation,
 	getStatusPageParamValidation,
 	getStatusPageQueryValidation,
-	imageValidation,
+	imageValidation, 
+	triggerNotificationBodyValidation,
+    telegramWebhookConfigValidation,
+    discordWebhookConfigValidation,
+    slackWebhookConfigValidation
 };