Merge branch 'develop' into enhancement/check-if-url-resolves

Server/controllers/checkController.js

@@ -1,13 +1,13 @@
 import {
-  createCheckParamValidation,
-  createCheckBodyValidation,
-  getChecksParamValidation,
-  getChecksQueryValidation,
-  getTeamChecksParamValidation,
-  getTeamChecksQueryValidation,
-  deleteChecksParamValidation,
-  deleteChecksByTeamIdParamValidation,
-  updateChecksTTLBodyValidation,
+	createCheckParamValidation,
+	createCheckBodyValidation,
+	getChecksParamValidation,
+	getChecksQueryValidation,
+	getTeamChecksParamValidation,
+	getTeamChecksQueryValidation,
+	deleteChecksParamValidation,
+	deleteChecksByTeamIdParamValidation,
+	updateChecksTTLBodyValidation,
 } from "../validation/joi.js";
 import { successMessages } from "../utils/messages.js";
 import jwt from "jsonwebtoken";
@@ -17,138 +17,138 @@ import { handleValidationError, handleError } from "./controllerUtils.js";
 const SERVICE_NAME = "checkController";
 
 const createCheck = async (req, res, next) => {
-  try {
-    await createCheckParamValidation.validateAsync(req.params);
-    await createCheckBodyValidation.validateAsync(req.body);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
+	try {
+		await createCheckParamValidation.validateAsync(req.params);
+		await createCheckBodyValidation.validateAsync(req.body);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
 
-  try {
-    const checkData = { ...req.body };
-    const check = await req.db.createCheck(checkData);
-    return res
-      .status(200)
-      .json({ success: true, msg: successMessages.CHECK_CREATE, data: check });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "createCheck"));
-  }
+	try {
+		const checkData = { ...req.body };
+		const check = await req.db.createCheck(checkData);
+		return res
+			.status(200)
+			.json({ success: true, msg: successMessages.CHECK_CREATE, data: check });
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "createCheck"));
+	}
 };
 
 const getChecks = async (req, res, next) => {
-  try {
-    await getChecksParamValidation.validateAsync(req.params);
-    await getChecksQueryValidation.validateAsync(req.query);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
+	try {
+		await getChecksParamValidation.validateAsync(req.params);
+		await getChecksQueryValidation.validateAsync(req.query);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
 
-  try {
-    const checks = await req.db.getChecks(req);
-    const checksCount = await req.db.getChecksCount(req);
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.CHECK_GET,
-      data: { checksCount, checks },
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "getChecks"));
-  }
+	try {
+		const checks = await req.db.getChecks(req);
+		const checksCount = await req.db.getChecksCount(req);
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.CHECK_GET,
+			data: { checksCount, checks },
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "getChecks"));
+	}
 };
 
 const getTeamChecks = async (req, res, next) => {
-  try {
-    await getTeamChecksParamValidation.validateAsync(req.params);
-    await getTeamChecksQueryValidation.validateAsync(req.query);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
-  try {
-    const checkData = await req.db.getTeamChecks(req);
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.CHECK_GET,
-      data: checkData,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "getTeamChecks"));
-  }
+	try {
+		await getTeamChecksParamValidation.validateAsync(req.params);
+		await getTeamChecksQueryValidation.validateAsync(req.query);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
+	try {
+		const checkData = await req.db.getTeamChecks(req);
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.CHECK_GET,
+			data: checkData,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "getTeamChecks"));
+	}
 };
 
 const deleteChecks = async (req, res, next) => {
-  try {
-    await deleteChecksParamValidation.validateAsync(req.params);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
+	try {
+		await deleteChecksParamValidation.validateAsync(req.params);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
 
-  try {
-    const deletedCount = await req.db.deleteChecks(req.params.monitorId);
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.CHECK_DELETE,
-      data: { deletedCount },
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "deleteChecks"));
-  }
+	try {
+		const deletedCount = await req.db.deleteChecks(req.params.monitorId);
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.CHECK_DELETE,
+			data: { deletedCount },
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "deleteChecks"));
+	}
 };
 
 const deleteChecksByTeamId = async (req, res, next) => {
-  try {
-    await deleteChecksByTeamIdParamValidation.validateAsync(req.params);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
+	try {
+		await deleteChecksByTeamIdParamValidation.validateAsync(req.params);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
 
-  try {
-    const deletedCount = await req.db.deleteChecksByTeamId(req.params.teamId);
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.CHECK_DELETE,
-      data: { deletedCount },
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "deleteChecksByTeamId"));
-  }
+	try {
+		const deletedCount = await req.db.deleteChecksByTeamId(req.params.teamId);
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.CHECK_DELETE,
+			data: { deletedCount },
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "deleteChecksByTeamId"));
+	}
 };
 
 const updateChecksTTL = async (req, res, next) => {
-  const SECONDS_PER_DAY = 86400;
+	const SECONDS_PER_DAY = 86400;
 
-  try {
-    await updateChecksTTLBodyValidation.validateAsync(req.body);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
+	try {
+		await updateChecksTTLBodyValidation.validateAsync(req.body);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
 
-  try {
-    // Get user's teamId
-    const token = getTokenFromHeaders(req.headers);
-    const { jwtSecret } = req.settingsService.getSettings();
-    const { teamId } = jwt.verify(token, jwtSecret);
-    const ttl = parseInt(req.body.ttl, 10) * SECONDS_PER_DAY;
-    await req.db.updateChecksTTL(teamId, ttl);
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.CHECK_UPDATE_TTL,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "updateTTL"));
-  }
+	try {
+		// Get user's teamId
+		const token = getTokenFromHeaders(req.headers);
+		const { jwtSecret } = req.settingsService.getSettings();
+		const { teamId } = jwt.verify(token, jwtSecret);
+		const ttl = parseInt(req.body.ttl, 10) * SECONDS_PER_DAY;
+		await req.db.updateChecksTTL(teamId, ttl);
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.CHECK_UPDATE_TTL,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "updateTTL"));
+	}
 };
 
 export {
-  createCheck,
-  getChecks,
-  getTeamChecks,
-  deleteChecks,
-  deleteChecksByTeamId,
-  updateChecksTTL,
+	createCheck,
+	getChecks,
+	getTeamChecks,
+	deleteChecks,
+	deleteChecksByTeamId,
+	updateChecksTTL,
 };

Server/controllers/controllerUtils.js

@@ -12,32 +12,15 @@ const handleError = (error, serviceName, method, status = 500) => {
 	return error;
 };
 
-const fetchMonitorCertificate = async (tls, monitor) => {
-	return new Promise((resolve, reject) => {
+const fetchMonitorCertificate = async (sslChecker, monitor) => {
+	try {
 		const monitorUrl = new URL(monitor.url);
 		const hostname = monitorUrl.hostname;
-		try {
-			let socket = tls.connect(
-				{
-					port: 443,
-					host: hostname,
-					servername: hostname, // this is required in case the server enabled SNI
-				},
-				() => {
-					try {
-						let x509Certificate = socket.getPeerX509Certificate();
-						resolve(x509Certificate);
-					} catch (error) {
-						reject(error);
-					} finally {
-						socket.end();
-					}
-				}
-			);
-		} catch (error) {
-			reject(error);
-		}
-	});
+		const cert = await sslChecker(hostname);
+		return cert;
+	} catch (error) {
+		throw error;
+	}
 };
 
 export { handleValidationError, handleError, fetchMonitorCertificate };

Server/controllers/inviteController.js

@@ -1,7 +1,7 @@
 import {
-  inviteRoleValidation,
-  inviteBodyValidation,
-  inviteVerificationBodyValidation,
+	inviteRoleValidation,
+	inviteBodyValidation,
+	inviteVerificationBodyValidation,
 } from "../validation/joi.js";
 import logger from "../utils/logger.js";
 import dotenv from "dotenv";
@@ -27,62 +27,58 @@ const SERVICE_NAME = "inviteController";
  * @throws {Error} If there is an error during the process, especially if there is a validation error (422).
  */
 const issueInvitation = async (req, res, next) => {
-  try {
-    // Only admins can invite
-    const token = getTokenFromHeaders(req.headers);
-    const { role, firstname, teamId } = jwt.decode(token);
-    req.body.teamId = teamId;
-    try {
-      await inviteRoleValidation.validateAsync({ roles: role });
-      await inviteBodyValidation.validateAsync(req.body);
-    } catch (error) {
-      next(handleValidationError(error, SERVICE_NAME));
-      return;
-    }
+	try {
+		// Only admins can invite
+		const token = getTokenFromHeaders(req.headers);
+		const { role, firstname, teamId } = jwt.decode(token);
+		req.body.teamId = teamId;
+		try {
+			await inviteRoleValidation.validateAsync({ roles: role });
+			await inviteBodyValidation.validateAsync(req.body);
+		} catch (error) {
+			next(handleValidationError(error, SERVICE_NAME));
+			return;
+		}
 
-    const inviteToken = await req.db.requestInviteToken({ ...req.body });
-    const { clientHost } = req.settingsService.getSettings();
-    req.emailService
-      .buildAndSendEmail(
-        "employeeActivationTemplate",
-        {
-          name: firstname,
-          link: `${clientHost}/register/${inviteToken.token}`,
-        },
-        req.body.email,
-        "Welcome to Uptime Monitor"
-      )
-      .catch((error) => {
-        logger.error("Error sending invite email", {
-          service: SERVICE_NAME,
-          error: error.message,
-        });
-      });
+		const inviteToken = await req.db.requestInviteToken({ ...req.body });
+		const { clientHost } = req.settingsService.getSettings();
+		req.emailService
+			.buildAndSendEmail(
+				"employeeActivationTemplate",
+				{
+					name: firstname,
+					link: `${clientHost}/register/${inviteToken.token}`,
+				},
+				req.body.email,
+				"Welcome to Uptime Monitor"
+			)
+			.catch((error) => {
+				logger.error("Error sending invite email", {
+					service: SERVICE_NAME,
+					error: error.message,
+				});
+			});
 
-    return res
-      .status(200)
-      .json({ success: true, msg: "Invite sent", data: inviteToken });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "inviteController"));
-  }
+		return res.status(200).json({ success: true, msg: "Invite sent", data: inviteToken });
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "inviteController"));
+	}
 };
 
 const inviteVerifyController = async (req, res, next) => {
-  try {
-    await inviteVerificationBodyValidation.validateAsync(req.body);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
+	try {
+		await inviteVerificationBodyValidation.validateAsync(req.body);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
 
-  try {
-    const invite = await req.db.getInviteToken(req.body.token);
-    res
-      .status(200)
-      .json({ status: "success", msg: "Invite verified", data: invite });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "inviteVerifyController"));
-  }
+	try {
+		const invite = await req.db.getInviteToken(req.body.token);
+		res.status(200).json({ status: "success", msg: "Invite verified", data: invite });
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "inviteVerifyController"));
+	}
 };
 
 export { issueInvitation, inviteVerifyController };

Server/controllers/maintenanceWindowController.js

@@ -1,11 +1,11 @@
 import {
-  createMaintenanceWindowBodyValidation,
-  editMaintenanceWindowByIdParamValidation,
-  editMaintenanceByIdWindowBodyValidation,
-  getMaintenanceWindowByIdParamValidation,
-  getMaintenanceWindowsByMonitorIdParamValidation,
-  getMaintenanceWindowsByTeamIdQueryValidation,
-  deleteMaintenanceWindowByIdParamValidation,
+	createMaintenanceWindowBodyValidation,
+	editMaintenanceWindowByIdParamValidation,
+	editMaintenanceByIdWindowBodyValidation,
+	getMaintenanceWindowByIdParamValidation,
+	getMaintenanceWindowsByMonitorIdParamValidation,
+	getMaintenanceWindowsByTeamIdQueryValidation,
+	deleteMaintenanceWindowByIdParamValidation,
 } from "../validation/joi.js";
 import jwt from "jsonwebtoken";
 import { getTokenFromHeaders } from "../utils/utils.js";
@@ -15,157 +15,153 @@ import { handleValidationError, handleError } from "./controllerUtils.js";
 const SERVICE_NAME = "maintenanceWindowController";
 
 const createMaintenanceWindows = async (req, res, next) => {
-  try {
-    await createMaintenanceWindowBodyValidation.validateAsync(req.body);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
-  try {
-    const token = getTokenFromHeaders(req.headers);
-    const { jwtSecret } = req.settingsService.getSettings();
-    const { teamId } = jwt.verify(token, jwtSecret);
-    const monitorIds = req.body.monitors;
-    const dbTransactions = monitorIds.map((monitorId) => {
-      return req.db.createMaintenanceWindow({
-        teamId,
-        monitorId,
-        name: req.body.name,
-        active: req.body.active ? req.body.active : true,
-        repeat: req.body.repeat,
-        start: req.body.start,
-        end: req.body.end,
-      });
-    });
-    await Promise.all(dbTransactions);
-    return res.status(201).json({
-      success: true,
-      msg: successMessages.MAINTENANCE_WINDOW_CREATE,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "createMaintenanceWindow"));
-  }
+	try {
+		await createMaintenanceWindowBodyValidation.validateAsync(req.body);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
+	try {
+		const token = getTokenFromHeaders(req.headers);
+		const { jwtSecret } = req.settingsService.getSettings();
+		const { teamId } = jwt.verify(token, jwtSecret);
+		const monitorIds = req.body.monitors;
+		const dbTransactions = monitorIds.map((monitorId) => {
+			return req.db.createMaintenanceWindow({
+				teamId,
+				monitorId,
+				name: req.body.name,
+				active: req.body.active ? req.body.active : true,
+				repeat: req.body.repeat,
+				start: req.body.start,
+				end: req.body.end,
+			});
+		});
+		await Promise.all(dbTransactions);
+		return res.status(201).json({
+			success: true,
+			msg: successMessages.MAINTENANCE_WINDOW_CREATE,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "createMaintenanceWindow"));
+	}
 };
 
 const getMaintenanceWindowById = async (req, res, next) => {
-  try {
-    await getMaintenanceWindowByIdParamValidation.validateAsync(req.params);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
-  try {
-    const maintenanceWindow = await req.db.getMaintenanceWindowById(
-      req.params.id
-    );
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.MAINTENANCE_WINDOW_GET_BY_ID,
-      data: maintenanceWindow,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "getMaintenanceWindowById"));
-  }
+	try {
+		await getMaintenanceWindowByIdParamValidation.validateAsync(req.params);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
+	try {
+		const maintenanceWindow = await req.db.getMaintenanceWindowById(req.params.id);
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.MAINTENANCE_WINDOW_GET_BY_ID,
+			data: maintenanceWindow,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "getMaintenanceWindowById"));
+	}
 };
 
 const getMaintenanceWindowsByTeamId = async (req, res, next) => {
-  try {
-    await getMaintenanceWindowsByTeamIdQueryValidation.validateAsync(req.query);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
+	try {
+		await getMaintenanceWindowsByTeamIdQueryValidation.validateAsync(req.query);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
 
-  try {
-    const token = getTokenFromHeaders(req.headers);
-    const { jwtSecret } = req.settingsService.getSettings();
-    const { teamId } = jwt.verify(token, jwtSecret);
-    const maintenanceWindows = await req.db.getMaintenanceWindowsByTeamId(
-      teamId,
-      req.query
-    );
+	try {
+		const token = getTokenFromHeaders(req.headers);
+		const { jwtSecret } = req.settingsService.getSettings();
+		const { teamId } = jwt.verify(token, jwtSecret);
+		const maintenanceWindows = await req.db.getMaintenanceWindowsByTeamId(
+			teamId,
+			req.query
+		);
 
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.MAINTENANCE_WINDOW_GET_BY_TEAM,
-      data: maintenanceWindows,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "getMaintenanceWindowsByUserId"));
-  }
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.MAINTENANCE_WINDOW_GET_BY_TEAM,
+			data: maintenanceWindows,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "getMaintenanceWindowsByUserId"));
+	}
 };
 
 const getMaintenanceWindowsByMonitorId = async (req, res, next) => {
-  try {
-    await getMaintenanceWindowsByMonitorIdParamValidation.validateAsync(
-      req.params
-    );
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
+	try {
+		await getMaintenanceWindowsByMonitorIdParamValidation.validateAsync(req.params);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
 
-  try {
-    const maintenanceWindows = await req.db.getMaintenanceWindowsByMonitorId(
-      req.params.monitorId
-    );
+	try {
+		const maintenanceWindows = await req.db.getMaintenanceWindowsByMonitorId(
+			req.params.monitorId
+		);
 
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.MAINTENANCE_WINDOW_GET_BY_USER,
-      data: maintenanceWindows,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "getMaintenanceWindowsByMonitorId"));
-  }
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.MAINTENANCE_WINDOW_GET_BY_USER,
+			data: maintenanceWindows,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "getMaintenanceWindowsByMonitorId"));
+	}
 };
 
 const deleteMaintenanceWindow = async (req, res, next) => {
-  try {
-    await deleteMaintenanceWindowByIdParamValidation.validateAsync(req.params);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
-  try {
-    await req.db.deleteMaintenanceWindowById(req.params.id);
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.MAINTENANCE_WINDOW_DELETE,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "deleteMaintenanceWindow"));
-  }
+	try {
+		await deleteMaintenanceWindowByIdParamValidation.validateAsync(req.params);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
+	try {
+		await req.db.deleteMaintenanceWindowById(req.params.id);
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.MAINTENANCE_WINDOW_DELETE,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "deleteMaintenanceWindow"));
+	}
 };
 
 const editMaintenanceWindow = async (req, res, next) => {
-  try {
-    await editMaintenanceWindowByIdParamValidation.validateAsync(req.params);
-    await editMaintenanceByIdWindowBodyValidation.validateAsync(req.body);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
-  try {
-    const editedMaintenanceWindow = await req.db.editMaintenanceWindowById(
-      req.params.id,
-      req.body
-    );
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.MAINTENANCE_WINDOW_EDIT,
-      data: editedMaintenanceWindow,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "editMaintenanceWindow"));
-  }
+	try {
+		await editMaintenanceWindowByIdParamValidation.validateAsync(req.params);
+		await editMaintenanceByIdWindowBodyValidation.validateAsync(req.body);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
+	try {
+		const editedMaintenanceWindow = await req.db.editMaintenanceWindowById(
+			req.params.id,
+			req.body
+		);
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.MAINTENANCE_WINDOW_EDIT,
+			data: editedMaintenanceWindow,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "editMaintenanceWindow"));
+	}
 };
 
 export {
-  createMaintenanceWindows,
-  getMaintenanceWindowById,
-  getMaintenanceWindowsByTeamId,
-  getMaintenanceWindowsByMonitorId,
-  deleteMaintenanceWindow,
-  editMaintenanceWindow,
+	createMaintenanceWindows,
+	getMaintenanceWindowById,
+	getMaintenanceWindowsByTeamId,
+	getMaintenanceWindowsByMonitorId,
+	deleteMaintenanceWindow,
+	editMaintenanceWindow,
 };

Server/controllers/monitorController.js

@@ -13,16 +13,12 @@ import {
 	getMonitorStatsByIdQueryValidation,
 	getCertificateParamValidation,
 } from "../validation/joi.js";
-import * as tls from "tls";
-
+import sslChecker from "ssl-checker";
 import { errorMessages, successMessages } from "../utils/messages.js";
 import jwt from "jsonwebtoken";
 import { getTokenFromHeaders } from "../utils/utils.js";
 import logger from "../utils/logger.js";
-import {
-  handleError,
-	handleValidationError,
-} from "./controllerUtils.js";
+import { handleError, handleValidationError } from "./controllerUtils.js";
 import dns from "dns";
 
 const SERVICE_NAME = "monitorController";
@@ -89,7 +85,7 @@ const getMonitorCertificate = async (req, res, next, fetchMonitorCertificate) =>
 	try {
 		const { monitorId } = req.params;
 		const monitor = await req.db.getMonitorById(monitorId);
-		const certificate = await fetchMonitorCertificate(tls, monitor);
+		const certificate = await fetchMonitorCertificate(sslChecker, monitor);
 		if (certificate && certificate.validTo) {
 			return res.status(200).json({
 				success: true,

Server/controllers/queueController.js

@@ -4,56 +4,54 @@ import { errorMessages, successMessages } from "../utils/messages.js";
 const SERVICE_NAME = "JobQueueController";
 
 const getMetrics = async (req, res, next) => {
-  try {
-    const metrics = await req.jobQueue.getMetrics();
-    res.status(200).json({
-      success: true,
-      msg: successMessages.QUEUE_GET_METRICS,
-      data: metrics,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "getMetrics"));
-    return;
-  }
+	try {
+		const metrics = await req.jobQueue.getMetrics();
+		res.status(200).json({
+			success: true,
+			msg: successMessages.QUEUE_GET_METRICS,
+			data: metrics,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "getMetrics"));
+		return;
+	}
 };
 
 const getJobs = async (req, res, next) => {
-  try {
-    const jobs = await req.jobQueue.getJobStats();
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.QUEUE_GET_METRICS,
-      data: jobs,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "getJobs"));
-    return;
-  }
+	try {
+		const jobs = await req.jobQueue.getJobStats();
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.QUEUE_GET_METRICS,
+			data: jobs,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "getJobs"));
+		return;
+	}
 };
 
 const addJob = async (req, res, next) => {
-  try {
-    await req.jobQueue.addJob(Math.random().toString(36).substring(7));
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.QUEUE_ADD_JOB,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "addJob"));
-    return;
-  }
+	try {
+		await req.jobQueue.addJob(Math.random().toString(36).substring(7));
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.QUEUE_ADD_JOB,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "addJob"));
+		return;
+	}
 };
 
 const obliterateQueue = async (req, res, next) => {
-  try {
-    await req.jobQueue.obliterate();
-    return res
-      .status(200)
-      .json({ success: true, msg: successMessages.QUEUE_OBLITERATE });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "obliterateQueue"));
-    return;
-  }
+	try {
+		await req.jobQueue.obliterate();
+		return res.status(200).json({ success: true, msg: successMessages.QUEUE_OBLITERATE });
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "obliterateQueue"));
+		return;
+	}
 };
 
 export { getMetrics, getJobs, addJob, obliterateQueue };

Server/controllers/settingsController.js

@@ -4,39 +4,39 @@ import { handleValidationError, handleError } from "./controllerUtils.js";
 const SERVICE_NAME = "SettingsController";
 
 const getAppSettings = async (req, res, next) => {
-  try {
-    const settings = { ...(await req.settingsService.getSettings()) };
-    delete settings.jwtSecret;
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.GET_APP_SETTINGS,
-      data: settings,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "getAppSettings"));
-  }
+	try {
+		const settings = { ...(await req.settingsService.getSettings()) };
+		delete settings.jwtSecret;
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.GET_APP_SETTINGS,
+			data: settings,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "getAppSettings"));
+	}
 };
 
 const updateAppSettings = async (req, res, next) => {
-  try {
-    await updateAppSettingsBodyValidation.validateAsync(req.body);
-  } catch (error) {
-    next(handleValidationError(error, SERVICE_NAME));
-    return;
-  }
+	try {
+		await updateAppSettingsBodyValidation.validateAsync(req.body);
+	} catch (error) {
+		next(handleValidationError(error, SERVICE_NAME));
+		return;
+	}
 
-  try {
-    await req.db.updateAppSettings(req.body);
-    const updatedSettings = { ...(await req.settingsService.reloadSettings()) };
-    delete updatedSettings.jwtSecret;
-    return res.status(200).json({
-      success: true,
-      msg: successMessages.UPDATE_APP_SETTINGS,
-      data: updatedSettings,
-    });
-  } catch (error) {
-    next(handleError(error, SERVICE_NAME, "updateAppSettings"));
-  }
+	try {
+		await req.db.updateAppSettings(req.body);
+		const updatedSettings = { ...(await req.settingsService.reloadSettings()) };
+		delete updatedSettings.jwtSecret;
+		return res.status(200).json({
+			success: true,
+			msg: successMessages.UPDATE_APP_SETTINGS,
+			data: updatedSettings,
+		});
+	} catch (error) {
+		next(handleError(error, SERVICE_NAME, "updateAppSettings"));
+	}
 };
 
 export { getAppSettings, updateAppSettings };