@oneuptime/common 7.0.3786 → 7.0.3815

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();

package/Server/Services/ScheduledMaintenanceStateService.ts

@@ -8,22 +8,27 @@ import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import LIMIT_MAX from "../../Types/Database/LimitMax";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
-import Model from "Common/Models/DatabaseModels/ScheduledMaintenanceState";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import ScheduledMaintenanceState from "Common/Models/DatabaseModels/ScheduledMaintenanceState";
 
-export class Service extends DatabaseService<Model> {
+export class Service extends DatabaseService<ScheduledMaintenanceState> {
   public constructor() {
-    super(Model);
+    super(ScheduledMaintenanceState);
   }
 
   protected override async onBeforeCreate(
-    createBy: CreateBy<Model>,
-  ): Promise<OnCreate<Model>> {
+    createBy: CreateBy<ScheduledMaintenanceState>,
+  ): Promise<OnCreate<ScheduledMaintenanceState>> {
     if (!createBy.data.order) {
-      throw new BadDataException("Incident State order is required");
+      throw new BadDataException(
+        "ScheduledMaintenance State order is required",
+      );
     }
 
     if (!createBy.data.projectId) {
-      throw new BadDataException("Incident State projectId is required");
+      throw new BadDataException(
+        "ScheduledMaintenance State projectId is required",
+      );
     }
 
     await this.rearrangeOrder(
@@ -39,15 +44,15 @@ export class Service extends DatabaseService<Model> {
   }
 
   protected override async onBeforeDelete(
-    deleteBy: DeleteBy<Model>,
-  ): Promise<OnDelete<Model>> {
+    deleteBy: DeleteBy<ScheduledMaintenanceState>,
+  ): Promise<OnDelete<ScheduledMaintenanceState>> {
     if (!deleteBy.query._id && !deleteBy.props.isRoot) {
       throw new BadDataException(
         "_id should be present when deleting scheduled maintenance states. Please try the delete with objectId",
       );
     }
 
-    let scheduledMaintenanceState: Model | null = null;
+    let scheduledMaintenanceState: ScheduledMaintenanceState | null = null;
 
     if (!deleteBy.props.isRoot) {
       scheduledMaintenanceState = await this.findOneBy({
@@ -69,11 +74,12 @@ export class Service extends DatabaseService<Model> {
   }
 
   protected override async onDeleteSuccess(
-    onDelete: OnDelete<Model>,
+    onDelete: OnDelete<ScheduledMaintenanceState>,
     _itemIdsBeforeDelete: ObjectID[],
-  ): Promise<OnDelete<Model>> {
-    const deleteBy: DeleteBy<Model> = onDelete.deleteBy;
-    const scheduledMaintenanceState: Model | null = onDelete.carryForward;
+  ): Promise<OnDelete<ScheduledMaintenanceState>> {
+    const deleteBy: DeleteBy<ScheduledMaintenanceState> = onDelete.deleteBy;
+    const scheduledMaintenanceState: ScheduledMaintenanceState | null =
+      onDelete.carryForward;
 
     if (!deleteBy.props.isRoot && scheduledMaintenanceState) {
       if (
@@ -96,8 +102,8 @@ export class Service extends DatabaseService<Model> {
   }
 
   protected override async onBeforeUpdate(
-    updateBy: UpdateBy<Model>,
-  ): Promise<OnUpdate<Model>> {
+    updateBy: UpdateBy<ScheduledMaintenanceState>,
+  ): Promise<OnUpdate<ScheduledMaintenanceState>> {
     if (updateBy.data.order && !updateBy.props.isRoot) {
       throw new BadDataException(
         "Scheduled Maintenance State order should not be updated. Delete this scheduled maintenance state and create a new state with the right order.",
@@ -113,24 +119,25 @@ export class Service extends DatabaseService<Model> {
     increaseOrder: boolean = true,
   ): Promise<void> {
     // get scheduledMaintenance with this order.
-    const scheduledMaintenanceStates: Array<Model> = await this.findBy({
-      query: {
-        order: QueryHelper.greaterThanEqualTo(currentOrder),
-        projectId: projectId,
-      },
-      limit: LIMIT_MAX,
-      skip: 0,
-      props: {
-        isRoot: true,
-      },
-      select: {
-        _id: true,
-        order: true,
-      },
-      sort: {
-        order: SortOrder.Ascending,
-      },
-    });
+    const scheduledMaintenanceStates: Array<ScheduledMaintenanceState> =
+      await this.findBy({
+        query: {
+          order: QueryHelper.greaterThanEqualTo(currentOrder),
+          projectId: projectId,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+        select: {
+          _id: true,
+          order: true,
+        },
+        sort: {
+          order: SortOrder.Ascending,
+        },
+      });
 
     let newOrder: number = currentOrder;
 
@@ -154,5 +161,86 @@ export class Service extends DatabaseService<Model> {
       });
     }
   }
+
+  public async getCompletedScheduledMaintenanceState(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<ScheduledMaintenanceState> {
+    const scheduledMaintenanceStates: Array<ScheduledMaintenanceState> =
+      await this.getAllScheduledMaintenanceStates({
+        projectId: data.projectId,
+        props: data.props,
+      });
+
+    const resolvedScheduledMaintenanceState:
+      | ScheduledMaintenanceState
+      | undefined = scheduledMaintenanceStates.find(
+      (scheduledMaintenanceState: ScheduledMaintenanceState) => {
+        return scheduledMaintenanceState?.isResolvedState;
+      },
+    );
+
+    if (!resolvedScheduledMaintenanceState) {
+      throw new BadDataException(
+        "Completed ScheduledMaintenance State not found for this project",
+      );
+    }
+
+    return resolvedScheduledMaintenanceState;
+  }
+
+  public async getAllScheduledMaintenanceStates(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<Array<ScheduledMaintenanceState>> {
+    const scheduledMaintenanceStates: Array<ScheduledMaintenanceState> =
+      await this.findBy({
+        query: {
+          projectId: data.projectId,
+        },
+        skip: 0,
+        limit: LIMIT_MAX,
+        sort: {
+          order: SortOrder.Ascending,
+        },
+        select: {
+          _id: true,
+          isResolvedState: true,
+          isOngoingState: true,
+          isScheduledState: true,
+          order: true,
+          name: true,
+        },
+        props: data.props,
+      });
+
+    return scheduledMaintenanceStates;
+  }
+
+  public async getOngoingScheduledMaintenanceState(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<ScheduledMaintenanceState> {
+    const scheduledMaintenanceStates: Array<ScheduledMaintenanceState> =
+      await this.getAllScheduledMaintenanceStates({
+        projectId: data.projectId,
+        props: data.props,
+      });
+
+    const ackScheduledMaintenanceState: ScheduledMaintenanceState | undefined =
+      scheduledMaintenanceStates.find(
+        (scheduledMaintenanceState: ScheduledMaintenanceState) => {
+          return scheduledMaintenanceState?.isOngoingState;
+        },
+      );
+
+    if (!ackScheduledMaintenanceState) {
+      throw new BadDataException(
+        "Ongoing ScheduledMaintenance State not found for this project",
+      );
+    }
+
+    return ackScheduledMaintenanceState;
+  }
 }
 export default new Service();

package/Server/Services/ScheduledMaintenanceStateTimelineService.ts

@@ -150,11 +150,35 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
           _id: true,
           color: true,
           name: true,
+          isResolvedState: true,
+          isOngoingState: true,
+          isScheduledState: true,
         },
       });
 
     const stateName: string = scheduledMaintenanceState?.name || "";
 
+    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!,
@@ -162,8 +186,16 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
         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.