@oneuptime/common 7.0.3786 → 7.0.3822

package/Server/Services/ScheduledMaintenanceOwnerUserService.ts

@@ -8,6 +8,11 @@ import UserService from "./UserService";
 import ScheduledMaintenanceFeedService from "./ScheduledMaintenanceFeedService";
 import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
 import { Gray500, Red500 } from "../../Types/BrandColors";
+import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -119,6 +124,35 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    // get notification rule where inviteOwners is true.
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await WorkspaceNotificationRuleService.getNotificationRulesWhereInviteOwnersIsTrue(
+        {
+          projectId: projectId!,
+          notificationFor: {
+            scheduledMaintenanceId: scheduledMaintenanceId,
+          },
+          notificationRuleEventType:
+            NotificationRuleEventType.ScheduledMaintenance,
+        },
+      );
+
+    WorkspaceNotificationRuleService.inviteUsersBasedOnRulesAndWorkspaceChannels(
+      {
+        notificationRules: notificationRules,
+        projectId: projectId!,
+        workspaceChannels:
+          await ScheduledMaintenanceService.getWorkspaceChannelForScheduledMaintenance(
+            {
+              scheduledMaintenanceId: scheduledMaintenanceId!,
+            },
+          ),
+        userIds: [userId!],
+      },
+    ).catch((error: Error) => {
+      logger.error(error);
+    });
+
     return createdItem;
   }
 }

package/Server/Services/ScheduledMaintenancePublicNoteService.ts

@@ -8,6 +8,8 @@ import ObjectID from "../../Types/ObjectID";
 import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/ScheduledMaintenanceFeed";
 import { Blue500, Indigo500 } from "../../Types/BrandColors";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import ScheduledMaintenanceService from "./ScheduledMaintenanceService";
+import ScheduledMaintenance from "../../Models/DatabaseModels/ScheduledMaintenance";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -34,6 +36,14 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
+    const scheduledMaintenanceId: ObjectID =
+      createdItem.scheduledMaintenanceId!;
+    const projectId: ObjectID = createdItem.projectId!;
+    const scheduledMaintenanceNumber: number | null =
+      await ScheduledMaintenanceService.getScheduledMaintenanceNumber({
+        scheduledMaintenanceId: scheduledMaintenanceId,
+      });
+
     await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem({
       scheduledMaintenanceId: createdItem.scheduledMaintenanceId!,
       projectId: createdItem.projectId!,
@@ -41,10 +51,14 @@ export class Service extends DatabaseService<Model> {
         ScheduledMaintenanceFeedEventType.PublicNote,
       displayColor: Indigo500,
       userId: userId || undefined,
-      feedInfoInMarkdown: `**Posted public note for this scheduled maintenance on status page**
-  
+      feedInfoInMarkdown: `📄 posted **public note** for this [Scheduled Maintenance ${scheduledMaintenanceNumber}](${(await ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard(projectId!, scheduledMaintenanceId!)).toString()}) on status page:
+    
 ${createdItem.note}
-            `,
+              `,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: userId || undefined,
+      },
     });
 
     return createdItem;
@@ -77,25 +91,53 @@ ${createdItem.note}
         onUpdate.updateBy.props.userId;
 
       for (const updatedItem of updatedItems) {
+        const scheduledMaintenance: ScheduledMaintenance =
+          updatedItem.scheduledMaintenance!;
+
         await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem(
           {
             scheduledMaintenanceId: updatedItem.scheduledMaintenanceId!,
             projectId: updatedItem.projectId!,
             scheduledMaintenanceFeedEventType:
-              ScheduledMaintenanceFeedEventType.PublicNote,
+              ScheduledMaintenanceFeedEventType.PrivateNote,
             displayColor: Blue500,
             userId: userId || undefined,
 
-            feedInfoInMarkdown: `**Updated Public Note**
-    
+            feedInfoInMarkdown: `📄 updated **Public Note** for this [Scheduled Maintenance ${scheduledMaintenance.scheduledMaintenanceNumber}](${(await ScheduledMaintenanceService.getScheduledMaintenanceLinkInDashboard(scheduledMaintenance.projectId!, scheduledMaintenance.id!)).toString()})
+        
 ${updatedItem.note}
-              `,
+                  `,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: userId || undefined,
+            },
           },
         );
       }
     }
     return onUpdate;
   }
+
+  public async addNote(data: {
+    userId: ObjectID;
+    scheduledMaintenanceId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+  }): Promise<Model> {
+    const publicNote: Model = new Model();
+    publicNote.createdByUserId = data.userId;
+    publicNote.scheduledMaintenanceId = data.scheduledMaintenanceId;
+    publicNote.projectId = data.projectId;
+    publicNote.note = data.note;
+    publicNote.postedAt = OneUptimeDate.getCurrentDate();
+
+    return this.create({
+      data: publicNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
 }
 
 export default new Service();

package/Server/Services/ScheduledMaintenanceService.ts

@@ -52,6 +52,10 @@ import { ScheduledMaintenanceFeedEventType } from "../../Models/DatabaseModels/S
 import { Gray500, Red500 } from "../../Types/BrandColors";
 import Label from "../../Models/DatabaseModels/Label";
 import LabelService from "./LabelService";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
+import { MessageBlocksByWorkspaceType } from "./WorkspaceNotificationRuleService";
+import ScheduledMaintenanceWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/ScheduledMaintenance";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -163,7 +167,7 @@ export class Service extends DatabaseService<Model> {
         }
 
         if (!statuspage.showScheduledMaintenanceEventsOnStatusPage) {
-          continue; // Do not send notification to subscribers if incidents are not visible on status page.
+          continue; // Do not send notification to subscribers if scheduledMaintenances are not visible on status page.
         }
 
         const subscribers: Array<StatusPageSubscriber> =
@@ -491,24 +495,111 @@ export class Service extends DatabaseService<Model> {
     const createdByUserId: ObjectID | undefined | null =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
+    // send message to workspaces - slack, teams,   etc.
+    const workspaceResult: {
+      channelsCreated: Array<NotificationRuleWorkspaceChannel>;
+    } | null =
+      await ScheduledMaintenanceWorkspaceMessages.createChannelsAndInviteUsersToChannels(
+        {
+          projectId: createdItem.projectId!,
+          scheduledMaintenanceId: createdItem.id!,
+          scheduledMaintenanceNumber: createdItem.scheduledMaintenanceNumber!,
+        },
+      );
+
+    if (workspaceResult && workspaceResult.channelsCreated?.length > 0) {
+      // update scheduledMaintenance with these channels.
+      await this.updateOneById({
+        id: createdItem.id!,
+        data: {
+          postUpdatesToWorkspaceChannels: workspaceResult.channelsCreated || [],
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    const scheduledMaintenance: Model | null = await this.findOneById({
+      id: createdItem.id!,
+      select: {
+        projectId: true,
+        scheduledMaintenanceNumber: true,
+        title: true,
+        description: true,
+        currentScheduledMaintenanceState: {
+          name: true,
+        },
+        startsAt: true,
+        endsAt: true,
+        monitors: {
+          name: true,
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!scheduledMaintenance) {
+      throw new BadDataException("Scheduled Maintenance not found");
+    }
+
+    let feedInfoInMarkdown: string = `#### 🕒 Scheduled Maintenance ${createdItem.scheduledMaintenanceNumber?.toString()} Created: 
+          
+**${createdItem.title || "No title provided."}**:
+    
+${createdItem.description || "No description provided."}
+    
+`;
+
+    // add starts at and ends at.
+    if (scheduledMaintenance.startsAt) {
+      feedInfoInMarkdown += `**Starts At**: ${OneUptimeDate.getDateAsLocalFormattedString(scheduledMaintenance.startsAt)} \n\n`;
+    }
+
+    if (scheduledMaintenance.endsAt) {
+      feedInfoInMarkdown += `**Ends At**: ${OneUptimeDate.getDateAsLocalFormattedString(scheduledMaintenance.endsAt)} \n\n`;
+    }
+
+    if (scheduledMaintenance.currentScheduledMaintenanceState?.name) {
+      feedInfoInMarkdown += `⏳ **Scheduled Maintenance State**: ${scheduledMaintenance.currentScheduledMaintenanceState.name} \n\n`;
+    }
+
+    if (
+      scheduledMaintenance.monitors &&
+      scheduledMaintenance.monitors.length > 0
+    ) {
+      feedInfoInMarkdown += `🌎 **Resources Affected**:\n`;
+
+      for (const monitor of scheduledMaintenance.monitors) {
+        feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(createdItem.projectId!, monitor.id!)).toString()})\n`;
+      }
+
+      feedInfoInMarkdown += `\n\n`;
+    }
+
+    const scheduledMaintenanceCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
+      await ScheduledMaintenanceWorkspaceMessages.getScheduledMaintenanceCreateMessageBlocks(
+        {
+          scheduledMaintenanceId: createdItem.id!,
+          projectId: createdItem.projectId!,
+        },
+      );
+
     await ScheduledMaintenanceFeedService.createScheduledMaintenanceFeedItem({
       scheduledMaintenanceId: createdItem.id!,
       projectId: createdItem.projectId!,
       scheduledMaintenanceFeedEventType:
         ScheduledMaintenanceFeedEventType.ScheduledMaintenanceCreated,
       displayColor: Red500,
-      feedInfoInMarkdown: `**Scheduled Maintenance #${createdItem.scheduledMaintenanceNumber?.toString()} Created**: 
-          
-**Scheduled Maintenance Title**:
-
-${createdItem.title || "No title provided."}
-
-**Description**:
-
-${createdItem.description || "No description provided."}
-    
-          `,
+      feedInfoInMarkdown: feedInfoInMarkdown,
       userId: createdByUserId || undefined,
+      workspaceNotification: {
+        appendMessageBlocks: scheduledMaintenanceCreateMessageBlocks,
+        sendWorkspaceNotification: true,
+      },
     });
 
     const timeline: ScheduledMaintenanceStateTimeline =
@@ -1051,5 +1142,277 @@ ${labels
       },
     });
   }
+
+  public async isScheduledMaintenanceCompleted(data: {
+    scheduledMaintenanceId: ObjectID;
+  }): Promise<boolean> {
+    const scheduledMaintenance: Model | null = await this.findOneBy({
+      query: {
+        _id: data.scheduledMaintenanceId,
+      },
+      select: {
+        projectId: true,
+        currentScheduledMaintenanceState: {
+          order: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!scheduledMaintenance) {
+      throw new BadDataException("ScheduledMaintenance not found");
+    }
+
+    if (!scheduledMaintenance.projectId) {
+      throw new BadDataException("Incient Project ID not found");
+    }
+
+    const resolvedScheduledMaintenanceState: ScheduledMaintenanceState =
+      await ScheduledMaintenanceStateService.getCompletedScheduledMaintenanceState(
+        {
+          projectId: scheduledMaintenance.projectId,
+          props: {
+            isRoot: true,
+          },
+        },
+      );
+
+    const currentScheduledMaintenanceStateOrder: number =
+      scheduledMaintenance.currentScheduledMaintenanceState!.order!;
+    const resolvedScheduledMaintenanceStateOrder: number =
+      resolvedScheduledMaintenanceState.order!;
+
+    if (
+      currentScheduledMaintenanceStateOrder >=
+      resolvedScheduledMaintenanceStateOrder
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+
+  public async getScheduledMaintenanceNumber(data: {
+    scheduledMaintenanceId: ObjectID;
+  }): Promise<number | null> {
+    const scheduledMaintenance: Model | null = await this.findOneById({
+      id: data.scheduledMaintenanceId,
+      select: {
+        scheduledMaintenanceNumber: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!scheduledMaintenance) {
+      throw new BadDataException("ScheduledMaintenance not found.");
+    }
+
+    return scheduledMaintenance.scheduledMaintenanceNumber || null;
+  }
+
+  public async isScheduledMaintenanceOngoing(data: {
+    scheduledMaintenanceId: ObjectID;
+  }): Promise<boolean> {
+    const scheduledMaintenance: Model | null = await this.findOneBy({
+      query: {
+        _id: data.scheduledMaintenanceId,
+      },
+      select: {
+        projectId: true,
+        currentScheduledMaintenanceState: {
+          order: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!scheduledMaintenance) {
+      throw new BadDataException("ScheduledMaintenance not found");
+    }
+
+    if (!scheduledMaintenance.projectId) {
+      throw new BadDataException("Incient Project ID not found");
+    }
+
+    const ackScheduledMaintenanceState: ScheduledMaintenanceState =
+      await ScheduledMaintenanceStateService.getOngoingScheduledMaintenanceState(
+        {
+          projectId: scheduledMaintenance.projectId,
+          props: {
+            isRoot: true,
+          },
+        },
+      );
+
+    const currentScheduledMaintenanceStateOrder: number =
+      scheduledMaintenance.currentScheduledMaintenanceState!.order!;
+    const ackScheduledMaintenanceStateOrder: number =
+      ackScheduledMaintenanceState.order!;
+
+    if (
+      currentScheduledMaintenanceStateOrder >= ackScheduledMaintenanceStateOrder
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+
+  public async markScheduledMaintenanceAsComplete(
+    scheduledMaintenanceId: ObjectID,
+    resolvedByUserId: ObjectID,
+  ): Promise<Model> {
+    const scheduledMaintenance: Model | null = await this.findOneById({
+      id: scheduledMaintenanceId,
+      select: {
+        projectId: true,
+        scheduledMaintenanceNumber: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!scheduledMaintenance || !scheduledMaintenance.projectId) {
+      throw new BadDataException("ScheduledMaintenance not found.");
+    }
+
+    const scheduledMaintenanceState: ScheduledMaintenanceState | null =
+      await ScheduledMaintenanceStateService.findOneBy({
+        query: {
+          projectId: scheduledMaintenance.projectId,
+          isResolvedState: true,
+        },
+        select: {
+          _id: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!scheduledMaintenanceState || !scheduledMaintenanceState.id) {
+      throw new BadDataException(
+        "Acknowledged state not found for this project. Please add acknowledged state from settings.",
+      );
+    }
+
+    const scheduledMaintenanceStateTimeline: ScheduledMaintenanceStateTimeline =
+      new ScheduledMaintenanceStateTimeline();
+    scheduledMaintenanceStateTimeline.projectId =
+      scheduledMaintenance.projectId;
+    scheduledMaintenanceStateTimeline.scheduledMaintenanceId =
+      scheduledMaintenanceId;
+    scheduledMaintenanceStateTimeline.scheduledMaintenanceStateId =
+      scheduledMaintenanceState.id;
+    scheduledMaintenanceStateTimeline.createdByUserId = resolvedByUserId;
+
+    await ScheduledMaintenanceStateTimelineService.create({
+      data: scheduledMaintenanceStateTimeline,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // store scheduledMaintenance metric
+
+    return scheduledMaintenance;
+  }
+
+  public async markScheduledMaintenanceAsOngoing(
+    scheduledMaintenanceId: ObjectID,
+    markedByUserId: ObjectID,
+  ): Promise<Model> {
+    const scheduledMaintenance: Model | null = await this.findOneById({
+      id: scheduledMaintenanceId,
+      select: {
+        projectId: true,
+        scheduledMaintenanceNumber: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!scheduledMaintenance || !scheduledMaintenance.projectId) {
+      throw new BadDataException("ScheduledMaintenance not found.");
+    }
+
+    const scheduledMaintenanceState: ScheduledMaintenanceState | null =
+      await ScheduledMaintenanceStateService.findOneBy({
+        query: {
+          projectId: scheduledMaintenance.projectId,
+          isOngoingState: true,
+        },
+        select: {
+          _id: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!scheduledMaintenanceState || !scheduledMaintenanceState.id) {
+      throw new BadDataException(
+        "Acknowledged state not found for this project. Please add acknowledged state from settings.",
+      );
+    }
+
+    const scheduledMaintenanceStateTimeline: ScheduledMaintenanceStateTimeline =
+      new ScheduledMaintenanceStateTimeline();
+    scheduledMaintenanceStateTimeline.projectId =
+      scheduledMaintenance.projectId;
+    scheduledMaintenanceStateTimeline.scheduledMaintenanceId =
+      scheduledMaintenanceId;
+    scheduledMaintenanceStateTimeline.scheduledMaintenanceStateId =
+      scheduledMaintenanceState.id;
+    scheduledMaintenanceStateTimeline.createdByUserId = markedByUserId;
+
+    await ScheduledMaintenanceStateTimelineService.create({
+      data: scheduledMaintenanceStateTimeline,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // store scheduledMaintenance metric
+
+    return scheduledMaintenance;
+  }
+
+  public async getWorkspaceChannelForScheduledMaintenance(data: {
+    scheduledMaintenanceId: ObjectID;
+    workspaceType?: WorkspaceType | null;
+  }): Promise<Array<NotificationRuleWorkspaceChannel>> {
+    const scheduledMaintenance: Model | null = await this.findOneById({
+      id: data.scheduledMaintenanceId,
+      select: {
+        postUpdatesToWorkspaceChannels: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!scheduledMaintenance) {
+      throw new BadDataException("ScheduledMaintenance not found.");
+    }
+
+    return (scheduledMaintenance.postUpdatesToWorkspaceChannels || []).filter(
+      (channel: NotificationRuleWorkspaceChannel) => {
+        if (!data.workspaceType) {
+          return true;
+        }
+
+        return channel.workspaceType === data.workspaceType;
+      },
+    );
+  }
 }
 export default new Service();