@oneuptime/common 7.0.3717 → 7.0.3786

package/Server/Services/ScheduledMaintenanceOwnerUserService.ts

@@ -67,15 +67,17 @@ export class Service extends DatabaseService<Model> {
         });
 
         if (user && user.name) {
-          await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
-            scheduledMaintenanceId: scheduledMaintenanceId,
-            projectId: projectId,
-            scheduledMaintenanceFeedEventType:
-              ScheduledMaintenanceFeedEventType.OwnerUserRemoved,
-            displayColor: Red500,
-            feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was removed from the scheduled maintenance as the owner.`,
-            userId: deleteByUserId || undefined,
-          });
+          await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem(
+            {
+              scheduledMaintenanceId: scheduledMaintenanceId,
+              projectId: projectId,
+              scheduledMaintenanceFeedEventType:
+                ScheduledMaintenanceFeedEventType.OwnerUserRemoved,
+              displayColor: Red500,
+              feedInfoInMarkdown: `Removed **${user.name.toString()}** (${user.email?.toString()}) from the scheduled maintenance as the owner.`,
+              userId: deleteByUserId || undefined,
+            },
+          );
         }
       }
     }
@@ -97,27 +99,23 @@ export class Service extends DatabaseService<Model> {
       createdItem.createdByUserId || onCreate.createBy.props.userId;
 
     if (scheduledMaintenanceId && userId && projectId) {
-      const user: User | null = await UserService.findOneById({
-        id: userId,
-        select: {
-          name: true,
-          email: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
-
-      if (user && user.name) {
-        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
-          scheduledMaintenanceId: scheduledMaintenanceId,
-          projectId: projectId,
-          scheduledMaintenanceFeedEventType:
-            ScheduledMaintenanceFeedEventType.OwnerUserAdded,
-          displayColor: Gray500,
-          feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was added to the scheduled maintenance as the owner.`,
-          userId: createdByUserId || undefined,
-        });
+      if (userId) {
+        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem(
+          {
+            scheduledMaintenanceId: scheduledMaintenanceId,
+            projectId: projectId,
+            scheduledMaintenanceFeedEventType:
+              ScheduledMaintenanceFeedEventType.OwnerUserAdded,
+            displayColor: Gray500,
+            feedInfoInMarkdown: `Added **${await UserService.getUserMarkdownString(
+              {
+                userId: userId,
+                projectId: projectId,
+              },
+            )}** to the scheduled maintenance as the owner.`,
+            userId: createdByUserId || undefined,
+          },
+        );
       }
     }
 

package/Server/Services/ScheduledMaintenancePublicNoteService.ts

@@ -34,7 +34,7 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
-    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem({
       scheduledMaintenanceId: createdItem.scheduledMaintenanceId!,
       projectId: createdItem.projectId!,
       scheduledMaintenanceFeedEventType:
@@ -77,19 +77,21 @@ ${createdItem.note}
         onUpdate.updateBy.props.userId;
 
       for (const updatedItem of updatedItems) {
-        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
-          scheduledMaintenanceId: updatedItem.scheduledMaintenanceId!,
-          projectId: updatedItem.projectId!,
-          scheduledMaintenanceFeedEventType:
-            ScheduledMaintenanceFeedEventType.PublicNote,
-          displayColor: Blue500,
-          userId: userId || undefined,
+        await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem(
+          {
+            scheduledMaintenanceId: updatedItem.scheduledMaintenanceId!,
+            projectId: updatedItem.projectId!,
+            scheduledMaintenanceFeedEventType:
+              ScheduledMaintenanceFeedEventType.PublicNote,
+            displayColor: Blue500,
+            userId: userId || undefined,
 
-          feedInfoInMarkdown: `**Updated Public Note**
+            feedInfoInMarkdown: `**Updated Public Note**
     
 ${updatedItem.note}
               `,
-        });
+          },
+        );
       }
     }
     return onUpdate;

package/Server/Services/ScheduledMaintenanceService.ts

@@ -162,6 +162,10 @@ export class Service extends DatabaseService<Model> {
           continue;
         }
 
+        if (!statuspage.showScheduledMaintenanceEventsOnStatusPage) {
+          continue; // Do not send notification to subscribers if incidents are not visible on status page.
+        }
+
         const subscribers: Array<StatusPageSubscriber> =
           await StatusPageSubscriberService.getSubscribersByStatusPage(
             statuspage.id!,
@@ -487,7 +491,7 @@ export class Service extends DatabaseService<Model> {
     const createdByUserId: ObjectID | undefined | null =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
-    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem({
       scheduledMaintenanceId: createdItem.id!,
       projectId: createdItem.projectId!,
       scheduledMaintenanceFeedEventType:
@@ -940,15 +944,17 @@ ${labels
         }
 
         if (shouldAddScheduledMaintenanceFeed) {
-          await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
-            scheduledMaintenanceId: scheduledMaintenanceId,
-            projectId: onUpdate.updateBy.props.tenantId as ObjectID,
-            scheduledMaintenanceFeedEventType:
-              ScheduledMaintenanceFeedEventType.ScheduledMaintenanceUpdated,
-            displayColor: Gray500,
-            feedInfoInMarkdown: feedInfoInMarkdown,
-            userId: createdByUserId || undefined,
-          });
+          await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem(
+            {
+              scheduledMaintenanceId: scheduledMaintenanceId,
+              projectId: onUpdate.updateBy.props.tenantId as ObjectID,
+              scheduledMaintenanceFeedEventType:
+                ScheduledMaintenanceFeedEventType.ScheduledMaintenanceUpdated,
+              displayColor: Gray500,
+              feedInfoInMarkdown: feedInfoInMarkdown,
+              userId: createdByUserId || undefined,
+            },
+          );
         }
       }
     }

package/Server/Services/ScheduledMaintenanceStateTimelineService.ts

@@ -155,7 +155,7 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
 
     const stateName: string = scheduledMaintenanceState?.name || "";
 
-    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem({
       scheduledMaintenanceId: createdItem.scheduledMaintenanceId!,
       projectId: createdItem.projectId!,
       scheduledMaintenanceFeedEventType:

package/Server/Services/StatusPageSubscriberService.ts

@@ -800,6 +800,9 @@ export class Service extends DatabaseService<Model> {
         subscriberTimezones: true,
         reportDataInDays: true,
         isReportEnabled: true,
+        showAnnouncementsOnStatusPage: true,
+        showIncidentsOnStatusPage: true,
+        showScheduledMaintenanceEventsOnStatusPage: true,
       },
     });
 

package/Server/Services/TeamMemberService.ts

@@ -32,6 +32,7 @@ import PositiveNumber from "../../Types/PositiveNumber";
 import Project from "Common/Models/DatabaseModels/Project";
 import TeamMember from "Common/Models/DatabaseModels/TeamMember";
 import User from "Common/Models/DatabaseModels/User";
+import ProjectUserService from "./ProjectUserService";
 
 export class TeamMemberService extends DatabaseService<TeamMember> {
   public constructor() {
@@ -190,6 +191,12 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
       onCreate.createBy.data.projectId!,
     );
 
+    ProjectUserService.refreshProjectUsersByProject({
+      projectId: onCreate.createBy.data.projectId!,
+    }).catch((err: Error) => {
+      logger.error(err);
+    });
+
     return createdItem;
   }
 
@@ -232,6 +239,12 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
           item.user?.email as Email,
         );
       }
+
+      ProjectUserService.refreshProjectUsersByProject({
+        projectId: item.projectId!,
+      }).catch((err: Error) => {
+        logger.error(err);
+      });
     }
 
     return { updateBy, carryForward: onUpdate.carryForward };
@@ -304,6 +317,13 @@ export class TeamMemberService extends DatabaseService<TeamMember> {
         item.userId!,
         item.projectId!,
       );
+
+      // refresh project users.
+      ProjectUserService.refreshProjectUsersByProject({
+        projectId: item.projectId!,
+      }).catch((err: Error) => {
+        logger.error(err);
+      });
     }
 
     return onDelete;

package/Server/Services/UserNotificationRuleService.ts

@@ -43,6 +43,11 @@ import Alert from "../../Models/DatabaseModels/Alert";
 import AlertService from "./AlertService";
 import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
 import AlertSeverityService from "./AlertSeverityService";
+import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -888,6 +893,75 @@ export class Service extends DatabaseService<Model> {
         isRoot: true,
       },
     });
+
+    // Alert workspace here. Invite users to channels for example. If they are not invited.
+
+    this.runWorkspaceRulesForOnCallNotification({
+      projectId: options.projectId,
+      alertId: options.triggeredByAlertId,
+      incidentId: options.triggeredByIncidentId,
+      userId: userId,
+    }).catch((error: Error) => {
+      logger.error(error);
+    });
+  }
+
+  public async runWorkspaceRulesForOnCallNotification(data: {
+    projectId: ObjectID;
+    incidentId?: ObjectID | undefined;
+    alertId?: ObjectID | undefined;
+    userId: ObjectID;
+  }): Promise<void> {
+    // if alert and incidient are both present, then throw an error.
+    if (data.incidentId && data.alertId) {
+      throw new BadDataException("Either incidentId or alertId is required.");
+    }
+
+    // if none are present, then throw an error.
+
+    if (!data.incidentId && !data.alertId) {
+      throw new BadDataException("Either incidentId or alertId is required.");
+    }
+
+    // get notification rule where inviteOwners is true.
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await WorkspaceNotificationRuleService.getNotificationRulesWhereInviteOwnersIsTrue(
+        {
+          projectId: data.projectId!,
+          notificationFor: {
+            incidentId: data.incidentId,
+            alertId: data.alertId,
+          },
+          notificationRuleEventType: data.incidentId
+            ? NotificationRuleEventType.Incident
+            : NotificationRuleEventType.Alert,
+        },
+      );
+
+    let workspaceChannels: Array<NotificationRuleWorkspaceChannel> = [];
+
+    if (data.incidentId) {
+      workspaceChannels = await IncidentService.getWorkspaceChannelForIncident({
+        incidentId: data.incidentId!,
+      });
+    }
+
+    if (data.alertId) {
+      workspaceChannels = await AlertService.getWorkspaceChannelForAlert({
+        alertId: data.alertId!,
+      });
+    }
+
+    WorkspaceNotificationRuleService.inviteUsersBasedOnRulesAndWorkspaceChannels(
+      {
+        notificationRules: notificationRules,
+        projectId: data.projectId!,
+        workspaceChannels: workspaceChannels,
+        userIds: [data.userId],
+      },
+    ).catch((error: Error) => {
+      logger.error(error);
+    });
   }
 
   protected override async onBeforeCreate(

package/Server/Services/UserOnCallLogService.ts

@@ -266,7 +266,7 @@ export class Service extends DatabaseService<Model> {
       id: createdItem.onCallDutyPolicyExecutionLogTimelineId!,
       data: {
         status: OnCallDutyExecutionLogTimelineStatus.NotificationSent,
-        statusMessage: "Initial notification sent to the user.",
+        statusMessage: "Alert Sent",
       },
       props: {
         isRoot: true,

package/Server/Services/UserService.ts

@@ -39,6 +39,41 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  public async getUserMarkdownString(data: {
+    userId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<string> {
+    const user: Model | null = await this.findOneBy({
+      query: {
+        _id: data.userId,
+      },
+      select: {
+        name: true,
+        email: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!user) {
+      return "";
+    }
+
+    return `[${user.name?.toString() || user.email?.toString() || "User"}](${(await this.getUserLinkInDashboard(data.projectId, data.userId)).toString()})`;
+  }
+
+  public async getUserLinkInDashboard(
+    projectId: ObjectID,
+    userId: ObjectID,
+  ): Promise<URL> {
+    const dashboardUrl: URL = await DatabaseConfig.getDashboardUrl();
+
+    return URL.fromString(dashboardUrl.toString()).addRoute(
+      `/${projectId.toString()}/settings/users/${userId.toString()}`,
+    );
+  }
+
   protected override async onCreateSuccess(
     _onCreate: OnCreate<Model>,
     createdItem: Model,