@oneuptime/common 7.0.3526 → 7.0.3538

package/Server/Services/UserNotificationRuleService.ts

@@ -39,6 +39,10 @@ import UserEmail from "Common/Models/DatabaseModels/UserEmail";
 import Model from "Common/Models/DatabaseModels/UserNotificationRule";
 import UserOnCallLog from "Common/Models/DatabaseModels/UserOnCallLog";
 import UserOnCallLogTimeline from "Common/Models/DatabaseModels/UserOnCallLogTimeline";
+import Alert from "../../Models/DatabaseModels/Alert";
+import AlertService from "./AlertService";
+import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
+import AlertSeverityService from "./AlertSeverityService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -50,6 +54,7 @@ export class Service extends DatabaseService<Model> {
     options: {
       projectId: ObjectID;
       triggeredByIncidentId?: ObjectID | undefined;
+      triggeredByAlertId?: ObjectID | undefined;
       userNotificationEventType: UserNotificationEventType;
       onCallPolicyExecutionLogId?: ObjectID | undefined;
       onCallPolicyId: ObjectID | undefined;
@@ -164,6 +169,10 @@ export class Service extends DatabaseService<Model> {
       logTimelineItem.triggeredByIncidentId = options.triggeredByIncidentId;
     }
 
+    if (options.triggeredByAlertId) {
+      logTimelineItem.triggeredByAlertId = options.triggeredByAlertId;
+    }
+
     if (options.onCallDutyPolicyExecutionLogTimelineId) {
       logTimelineItem.onCallDutyPolicyExecutionLogTimelineId =
         options.onCallDutyPolicyExecutionLogTimelineId;
@@ -172,6 +181,7 @@ export class Service extends DatabaseService<Model> {
     // add status and status message and save.
 
     let incident: Incident | null = null;
+    let alert: Alert | null = null;
 
     if (
       options.userNotificationEventType ===
@@ -202,15 +212,89 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
-    if (!incident) {
-      throw new BadDataException("Incident not found.");
+    if (
+      options.userNotificationEventType ===
+        UserNotificationEventType.AlertCreated &&
+      options.triggeredByAlertId
+    ) {
+      alert = await AlertService.findOneById({
+        id: options.triggeredByAlertId!,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          _id: true,
+          title: true,
+          description: true,
+          projectId: true,
+          project: {
+            name: true,
+          },
+          currentAlertState: {
+            name: true,
+          },
+          alertSeverity: {
+            name: true,
+          },
+        },
+      });
+    }
+
+    if (!incident && !alert) {
+      throw new BadDataException("Incident or Alert not found.");
     }
 
     if (
       notificationRuleItem.userEmail?.email &&
       notificationRuleItem.userEmail?.isVerified
     ) {
-      // send email.
+      // send email for alert.
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertCreated &&
+        alert
+      ) {
+        // create an error log.
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending email to ${notificationRuleItem.userEmail?.email.toString()}`;
+        logTimelineItem.userEmailId = notificationRuleItem.userEmail.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const emailMessage: EmailMessage =
+          await this.generateEmailTemplateForAlertCreated(
+            notificationRuleItem.userEmail?.email,
+            alert,
+            updatedLog.id!,
+          );
+
+        // send email.
+
+        MailService.sendMail(emailMessage, {
+          userOnCallLogTimelineId: updatedLog.id!,
+          projectId: options.projectId,
+        }).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error sending email.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
+
+      // send email for incident
       if (
         options.userNotificationEventType ===
           UserNotificationEventType.IncidentCreated &&
@@ -278,7 +362,51 @@ export class Service extends DatabaseService<Model> {
       notificationRuleItem.userSms?.phone &&
       notificationRuleItem.userSms?.isVerified
     ) {
-      // send sms.
+      //send sms for alert
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertCreated &&
+        alert
+      ) {
+        // create an error log.
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending SMS to ${notificationRuleItem.userSms?.phone.toString()}.`;
+        logTimelineItem.userSmsId = notificationRuleItem.userSms.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const smsMessage: SMS = await this.generateSmsTemplateForAlertCreated(
+          notificationRuleItem.userSms.phone,
+          alert,
+          updatedLog.id!,
+        );
+
+        // send email.
+
+        SmsService.sendSms(smsMessage, {
+          projectId: alert.projectId,
+          userOnCallLogTimelineId: updatedLog.id!,
+        }).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error sending SMS.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      }
+
+      // send sms for incident
       if (
         options.userNotificationEventType ===
           UserNotificationEventType.IncidentCreated &&
@@ -345,43 +473,94 @@ export class Service extends DatabaseService<Model> {
       notificationRuleItem.userCall?.phone &&
       notificationRuleItem.userCall?.isVerified
     ) {
-      // send call.
-      logTimelineItem.status = UserNotificationStatus.Sending;
-      logTimelineItem.statusMessage = `Making a call to ${notificationRuleItem.userCall?.phone.toString()}.`;
-      logTimelineItem.userCallId = notificationRuleItem.userCall.id!;
-
-      const updatedLog: UserOnCallLogTimeline =
-        await UserOnCallLogTimelineService.create({
-          data: logTimelineItem,
-          props: {
-            isRoot: true,
-          },
+      // send call for alert
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertCreated &&
+        alert
+      ) {
+        // create an error log.
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Making a call to ${notificationRuleItem.userCall?.phone.toString()}.`;
+        logTimelineItem.userCallId = notificationRuleItem.userCall.id!;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const callRequest: CallRequest =
+          await this.generateCallTemplateForAlertCreated(
+            notificationRuleItem.userCall?.phone,
+            alert,
+            updatedLog.id!,
+          );
+
+        // send email.
+
+        CallService.makeCall(callRequest, {
+          projectId: alert.projectId,
+          userOnCallLogTimelineId: updatedLog.id!,
+        }).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error making call.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
         });
+      }
 
-      const callRequest: CallRequest =
-        await this.generateCallTemplateForIncidentCreated(
-          notificationRuleItem.userCall?.phone,
-          incident,
-          updatedLog.id!,
-        );
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.IncidentCreated &&
+        incident
+      ) {
+        // send call for incident
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Making a call to ${notificationRuleItem.userCall?.phone.toString()}.`;
+        logTimelineItem.userCallId = notificationRuleItem.userCall.id!;
 
-      // send email.
-
-      CallService.makeCall(callRequest, {
-        projectId: incident.projectId,
-        userOnCallLogTimelineId: updatedLog.id!,
-      }).catch(async (err: Error) => {
-        await UserOnCallLogTimelineService.updateOneById({
-          id: updatedLog.id!,
-          data: {
-            status: UserNotificationStatus.Error,
-            statusMessage: err.message || "Error making call.",
-          },
-          props: {
-            isRoot: true,
-          },
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const callRequest: CallRequest =
+          await this.generateCallTemplateForIncidentCreated(
+            notificationRuleItem.userCall?.phone,
+            incident,
+            updatedLog.id!,
+          );
+
+        // send email.
+
+        CallService.makeCall(callRequest, {
+          projectId: incident.projectId,
+          userOnCallLogTimelineId: updatedLog.id!,
+        }).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error making call.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
         });
-      });
+      }
     }
 
     if (
@@ -401,6 +580,56 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
+  public async generateCallTemplateForAlertCreated(
+    to: Phone,
+    alert: Alert,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<CallRequest> {
+    const host: Hostname = await DatabaseConfig.getHost();
+
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+
+    const callRequest: CallRequest = {
+      to: to,
+      data: [
+        {
+          sayMessage: "This is a call from OneUptime",
+        },
+        {
+          sayMessage: "A new alert has been created",
+        },
+        {
+          sayMessage: alert.title!,
+        },
+        {
+          introMessage: "To acknowledge this alert press 1",
+          numDigits: 1,
+          timeoutInSeconds: 10,
+          noInputMessage: "You have not entered any input. Good bye",
+          onInputCallRequest: {
+            "1": {
+              sayMessage: "You have acknowledged this alert. Good bye",
+            },
+            default: {
+              sayMessage: "Invalid input. Good bye",
+            },
+          },
+          responseUrl: new URL(
+            httpProtocol,
+            host,
+            new Route(AppApiRoute.toString())
+              .addRoute(new UserOnCallLogTimeline().crudApiPath!)
+              .addRoute(
+                "/call/gather-input/" + userOnCallLogTimelineId.toString(),
+              ),
+          ),
+        },
+      ],
+    };
+
+    return callRequest;
+  }
+
   public async generateCallTemplateForIncidentCreated(
     to: Phone,
     incident: Incident,
@@ -451,6 +680,35 @@ export class Service extends DatabaseService<Model> {
     return callRequest;
   }
 
+  public async generateSmsTemplateForAlertCreated(
+    to: Phone,
+    alert: Alert,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<SMS> {
+    const host: Hostname = await DatabaseConfig.getHost();
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+
+    const shortUrl: ShortLink = await ShortLinkService.saveShortLinkFor(
+      new URL(
+        httpProtocol,
+        host,
+        new Route(AppApiRoute.toString())
+          .addRoute(new UserOnCallLogTimeline().crudApiPath!)
+          .addRoute("/acknowledge/" + userOnCallLogTimelineId.toString()),
+      ),
+    );
+    const url: URL = await ShortLinkService.getShortenedUrl(shortUrl);
+
+    const sms: SMS = {
+      to,
+      message: `This is a message from OneUptime. A new alert has been created. ${
+        alert.title
+      }. To acknowledge this alert, please click on the following link ${url.toString()}`,
+    };
+
+    return sms;
+  }
+
   public async generateSmsTemplateForIncidentCreated(
     to: Phone,
     incident: Incident,
@@ -480,6 +738,45 @@ export class Service extends DatabaseService<Model> {
     return sms;
   }
 
+  public async generateEmailTemplateForAlertCreated(
+    to: Email,
+    alert: Alert,
+    userOnCallLogTimelineId: ObjectID,
+  ): Promise<EmailMessage> {
+    const host: Hostname = await DatabaseConfig.getHost();
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+
+    const vars: Dictionary<string> = {
+      alertTitle: alert.title!,
+      projectName: alert.project!.name!,
+      currentState: alert.currentAlertState!.name!,
+      alertDescription: await Markdown.convertToHTML(
+        alert.description! || "",
+        MarkdownContentType.Email,
+      ),
+      alertSeverity: alert.alertSeverity!.name!,
+      alertViewLink: (
+        await AlertService.getAlertLinkInDashboard(alert.projectId!, alert.id!)
+      ).toString(),
+      acknowledgeAlertLink: new URL(
+        httpProtocol,
+        host,
+        new Route(AppApiRoute.toString())
+          .addRoute(new UserOnCallLogTimeline().crudApiPath!)
+          .addRoute("/acknowledge/" + userOnCallLogTimelineId.toString()),
+      ).toString(),
+    };
+
+    const emailMessage: EmailMessage = {
+      toEmail: to!,
+      templateType: EmailTemplateType.AcknowledgeAlert,
+      vars: vars,
+      subject: "ACTION REQUIRED: Alert created - " + alert.title!,
+    };
+
+    return emailMessage;
+  }
+
   public async generateEmailTemplateForIncidentCreated(
     to: Email,
     incident: Incident,
@@ -529,6 +826,7 @@ export class Service extends DatabaseService<Model> {
     options: {
       projectId: ObjectID;
       triggeredByIncidentId?: ObjectID | undefined;
+      triggeredByAlertId?: ObjectID | undefined;
       userNotificationEventType: UserNotificationEventType;
       onCallPolicyExecutionLogId?: ObjectID | undefined;
       onCallPolicyId: ObjectID | undefined;
@@ -548,6 +846,10 @@ export class Service extends DatabaseService<Model> {
       userOnCallLog.triggeredByIncidentId = options.triggeredByIncidentId;
     }
 
+    if (options.triggeredByAlertId) {
+      userOnCallLog.triggeredByAlertId = options.triggeredByAlertId;
+    }
+
     userOnCallLog.userNotificationEventType = options.userNotificationEventType;
 
     if (options.onCallPolicyExecutionLogId) {
@@ -608,11 +910,13 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
-  public async addDefaultNotificationRuleForUser(
-    projectId: ObjectID,
-    userId: ObjectID,
-    email: Email,
-  ): Promise<void> {
+  public async addDefaultIncidentNotificationRuleForUser(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+    userEmail: UserEmail;
+  }): Promise<void> {
+    const { projectId, userId, userEmail } = data;
+
     const incidentSeverities: Array<IncidentSeverity> =
       await IncidentSeverityService.findBy({
         query: {
@@ -628,44 +932,76 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
-    //check userEmail
+    // create for incident severities.
+    for (const incidentSeverity of incidentSeverities) {
+      //check if this rule already exists.
+      const existingRule: Model | null = await this.findOneBy({
+        query: {
+          projectId,
+          userId,
+          userEmailId: userEmail.id!,
+          incidentSeverityId: incidentSeverity.id!,
+          ruleType: NotificationRuleType.ON_CALL_EXECUTED,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
 
-    let userEmail: UserEmail | null = await UserEmailService.findOneBy({
-      query: {
-        projectId,
-        userId,
-        email,
-      },
-      props: {
-        isRoot: true,
-      },
-    });
+      if (existingRule) {
+        continue; // skip this rule.
+      }
 
-    if (!userEmail) {
-      userEmail = new UserEmail();
-      userEmail.projectId = projectId;
-      userEmail.userId = userId;
-      userEmail.email = email;
-      userEmail.isVerified = true;
+      const notificationRule: Model = new Model();
 
-      userEmail = await UserEmailService.create({
-        data: userEmail,
+      notificationRule.projectId = projectId;
+      notificationRule.userId = userId;
+      notificationRule.userEmailId = userEmail.id!;
+      notificationRule.incidentSeverityId = incidentSeverity.id!;
+      notificationRule.notifyAfterMinutes = 0;
+      notificationRule.ruleType = NotificationRuleType.ON_CALL_EXECUTED;
+
+      await this.create({
+        data: notificationRule,
         props: {
           isRoot: true,
         },
       });
     }
+  }
 
-    // create for incident severities.
-    for (const incidentSeverity of incidentSeverities) {
+  public async addDefaultAlertNotificationRulesForUser(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+    userEmail: UserEmail;
+  }): Promise<void> {
+    const { projectId, userId, userEmail } = data;
+
+    const alertSeverities: Array<AlertSeverity> =
+      await AlertSeverityService.findBy({
+        query: {
+          projectId,
+        },
+        props: {
+          isRoot: true,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        select: {
+          _id: true,
+        },
+      });
+
+    // create for Alert severities.
+    for (const alertSeverity of alertSeverities) {
       //check if this rule already exists.
       const existingRule: Model | null = await this.findOneBy({
         query: {
           projectId,
           userId,
           userEmailId: userEmail.id!,
-          incidentSeverityId: incidentSeverity.id!,
-          ruleType: NotificationRuleType.ON_CALL_INCIDENT_CREATED,
+          alertSeverityId: alertSeverity.id!,
+          ruleType: NotificationRuleType.ON_CALL_EXECUTED,
         },
         props: {
           isRoot: true,
@@ -681,9 +1017,9 @@ export class Service extends DatabaseService<Model> {
       notificationRule.projectId = projectId;
       notificationRule.userId = userId;
       notificationRule.userEmailId = userEmail.id!;
-      notificationRule.incidentSeverityId = incidentSeverity.id!;
+      notificationRule.alertSeverityId = alertSeverity.id!;
       notificationRule.notifyAfterMinutes = 0;
-      notificationRule.ruleType = NotificationRuleType.ON_CALL_INCIDENT_CREATED;
+      notificationRule.ruleType = NotificationRuleType.ON_CALL_EXECUTED;
 
       await this.create({
         data: notificationRule,
@@ -692,6 +1028,53 @@ export class Service extends DatabaseService<Model> {
         },
       });
     }
+  }
+
+  public async addDefaultNotificationRuleForUser(
+    projectId: ObjectID,
+    userId: ObjectID,
+    email: Email,
+  ): Promise<void> {
+    let userEmail: UserEmail | null = await UserEmailService.findOneBy({
+      query: {
+        projectId,
+        userId,
+        email,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!userEmail) {
+      userEmail = new UserEmail();
+      userEmail.projectId = projectId;
+      userEmail.userId = userId;
+      userEmail.email = email;
+      userEmail.isVerified = true;
+
+      userEmail = await UserEmailService.create({
+        data: userEmail,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    // add default incident rules for user
+    await this.addDefaultIncidentNotificationRuleForUser({
+      projectId,
+      userId,
+      userEmail,
+    });
+
+    // add default alert rules for user, just like the incident
+
+    await this.addDefaultAlertNotificationRulesForUser({
+      projectId,
+      userId,
+      userEmail,
+    });
 
     //check if this rule already exists.
     const existingRuleOnCall: Model | null = await this.findOneBy({