@oneuptime/common 7.0.3718 → 7.0.3815

package/Server/Services/ScheduledMaintenanceStateTimelineService.ts

@@ -150,20 +150,52 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
           _id: true,
           color: true,
           name: true,
+          isResolvedState: true,
+          isOngoingState: true,
+          isScheduledState: true,
         },
       });
 
     const stateName: string = scheduledMaintenanceState?.name || "";
 
-    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeed({
+    const scheduledMaintenanceNumber: number | null =
+      await ScheduledMaintenanceService.getScheduledMaintenanceNumber({
+        scheduledMaintenanceId: createdItem.scheduledMaintenanceId,
+      });
+
+    // if resolved state then change emoji to ✅.
+    let stateEmoji: string = "➡️";
+
+    if (scheduledMaintenanceState?.isResolvedState) {
+      stateEmoji = "✅";
+    } else if (scheduledMaintenanceState?.isOngoingState) {
+      // eyes emoji for acknowledged state.
+      stateEmoji = "⏳";
+    } else if (scheduledMaintenanceState?.isScheduledState) {
+      stateEmoji = "🕒";
+    }
+
+    const projectId: ObjectID = createdItem.projectId!;
+    const scheduledMaintenanceId: ObjectID =
+      createdItem.scheduledMaintenanceId!;
+
+    await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem({
       scheduledMaintenanceId: createdItem.scheduledMaintenanceId!,
       projectId: createdItem.projectId!,
       scheduledMaintenanceFeedEventType:
         ScheduledMaintenanceFeedEventType.ScheduledMaintenanceStateChanged,
       displayColor: scheduledMaintenanceState?.color,
       feedInfoInMarkdown:
-        "**Scheduled Maintenance State** changed to **" + stateName + "**",
+        stateEmoji +
+        ` Changed **[Scheduled Maintenance ${scheduledMaintenanceNumber}](${(await ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard(projectId!, scheduledMaintenanceId!)).toString()}) State** to **` +
+        stateName +
+        "**",
       userId: createdItem.createdByUserId || onCreate.createBy.props.userId,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId:
+          createdItem.createdByUserId || onCreate.createBy.props.userId,
+      },
     });
 
     // TODO: DELETE THIS WHEN WORKFLOW IS IMPLEMENMTED.

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,