@oneuptime/common 7.0.3717 → 7.0.3786

package/Server/Services/IncidentService.ts

@@ -54,13 +54,10 @@ import Label from "../../Models/DatabaseModels/Label";
 import LabelService from "./LabelService";
 import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
 import IncidentSeverityService from "./IncidentSeverityService";
-import {
-  WorkspaceMessageBlock,
-  WorkspacePayloadMarkdown,
-} from "../../Types/Workspace/WorkspaceMessagePayload";
-import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
-import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
-import { WorkspaceChannel } from "../Utils/Workspace/WorkspaceBase";
+import IncidentWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/Incident";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import { MessageBlocksByWorkspaceType } from "./WorkspaceNotificationRuleService";
+import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -70,6 +67,51 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
+  public async isIncidentResolved(data: {
+    incidentId: ObjectID;
+  }): Promise<boolean> {
+    const incident: Model | null = await this.findOneBy({
+      query: {
+        _id: data.incidentId,
+      },
+      select: {
+        projectId: true,
+        currentIncidentState: {
+          order: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!incident) {
+      throw new BadDataException("Incident not found");
+    }
+
+    if (!incident.projectId) {
+      throw new BadDataException("Incient Project ID not found");
+    }
+
+    const resolvedIncidentState: IncidentState =
+      await IncidentStateService.getResolvedIncidentState({
+        projectId: incident.projectId,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    const currentIncidentStateOrder: number =
+      incident.currentIncidentState!.order!;
+    const resolvedIncidentStateOrder: number = resolvedIncidentState.order!;
+
+    if (currentIncidentStateOrder >= resolvedIncidentStateOrder) {
+      return true;
+    }
+
+    return false;
+  }
+
   public async isIncidentAcknowledged(data: {
     incidentId: ObjectID;
   }): Promise<boolean> {
@@ -115,14 +157,73 @@ export class Service extends DatabaseService<Model> {
     return false;
   }
 
+  public async resolveIncident(
+    incidentId: ObjectID,
+    resolvedByUserId: ObjectID,
+  ): Promise<Model> {
+    const incident: Model | null = await this.findOneById({
+      id: incidentId,
+      select: {
+        projectId: true,
+        incidentNumber: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!incident || !incident.projectId) {
+      throw new BadDataException("Incident not found.");
+    }
+
+    const incidentState: IncidentState | null =
+      await IncidentStateService.findOneBy({
+        query: {
+          projectId: incident.projectId,
+          isResolvedState: true,
+        },
+        select: {
+          _id: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!incidentState || !incidentState.id) {
+      throw new BadDataException(
+        "Acknowledged state not found for this project. Please add acknowledged state from settings.",
+      );
+    }
+
+    const incidentStateTimeline: IncidentStateTimeline =
+      new IncidentStateTimeline();
+    incidentStateTimeline.projectId = incident.projectId;
+    incidentStateTimeline.incidentId = incidentId;
+    incidentStateTimeline.incidentStateId = incidentState.id;
+    incidentStateTimeline.createdByUserId = resolvedByUserId;
+
+    await IncidentStateTimelineService.create({
+      data: incidentStateTimeline,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    // store incident metric
+
+    return incident;
+  }
+
   public async acknowledgeIncident(
     incidentId: ObjectID,
     acknowledgedByUserId: ObjectID,
-  ): Promise<void> {
+  ): Promise<Model> {
     const incident: Model | null = await this.findOneById({
       id: incidentId,
       select: {
         projectId: true,
+        incidentNumber: true,
       },
       props: {
         isRoot: true,
@@ -168,6 +269,8 @@ export class Service extends DatabaseService<Model> {
     });
 
     // store incident metric
+
+    return incident;
   }
 
   public async getExistingIncidentNumberForProject(data: {
@@ -276,22 +379,13 @@ export class Service extends DatabaseService<Model> {
         userId = createBy.data.createdByUser.id;
       }
 
-      const user: User | null = await UserService.findOneBy({
-        query: {
-          _id: userId?.toString() as string,
-        },
-        select: {
-          _id: true,
-          name: true,
-          email: true,
-        },
-        props: {
-          isRoot: true,
-        },
-      });
-
-      if (user) {
-        createBy.data.rootCause = `Incident created by ${user.name} (${user.email})`;
+      if (userId) {
+        createBy.data.rootCause = `Incident created by ${await UserService.getUserMarkdownString(
+          {
+            userId: userId!,
+            projectId: projectId,
+          },
+        )}`;
       }
     }
 
@@ -316,6 +410,35 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("id is required");
     }
 
+    const incident: Model | null = await this.findOneById({
+      id: createdItem.id,
+      select: {
+        projectId: true,
+        incidentNumber: true,
+        title: true,
+        description: true,
+        incidentSeverity: {
+          name: true,
+        },
+        rootCause: true,
+        remediationNotes: true,
+        currentIncidentState: {
+          name: true,
+        },
+        monitors: {
+          name: true,
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!incident) {
+      throw new BadDataException("Incident not found");
+    }
+
     // release the mutex.
     if (onCreate.carryForward && onCreate.carryForward.mutex) {
       const mutex: SemaphoreMutex = onCreate.carryForward.mutex;
@@ -343,23 +466,91 @@ export class Service extends DatabaseService<Model> {
     const createdByUserId: ObjectID | undefined | null =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
-    await IncidentFeedService.createIncidentFeed({
-      incidentId: createdItem.id!,
-      projectId: createdItem.projectId!,
-      incidentFeedEventType: IncidentFeedEventType.IncidentCreated,
-      displayColor: Red500,
-      feedInfoInMarkdown: `**Incident #${createdItem.incidentNumber?.toString()} Created**: 
-      
-**Incident Title**:
+    // send message to workspaces - slack, teams,   etc.
+    const workspaceResult: {
+      channelsCreated: Array<NotificationRuleWorkspaceChannel>;
+    } | null =
+      await IncidentWorkspaceMessages.createChannelsAndInviteUsersToChannels({
+        projectId: createdItem.projectId,
+        incidentId: createdItem.id!,
+        incidentNumber: createdItem.incidentNumber!,
+      });
 
-${createdItem.title || "No title provided."}
+    if (workspaceResult && workspaceResult.channelsCreated?.length > 0) {
+      // update incident with these channels.
+      await this.updateOneById({
+        id: createdItem.id!,
+        data: {
+          postUpdatesToWorkspaceChannels: workspaceResult.channelsCreated || [],
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
 
-**Description**:
+    let feedInfoInMarkdown: string = `#### 🚨 Incident ${createdItem.incidentNumber?.toString()} Created: 
+      
+**${createdItem.title || "No title provided."}**:
 
 ${createdItem.description || "No description provided."}
 
-      `,
+`;
+
+    if (incident.currentIncidentState?.name) {
+      feedInfoInMarkdown += `🔴 **Incident State**: ${incident.currentIncidentState.name} \n\n`;
+    }
+
+    if (incident.incidentSeverity?.name) {
+      feedInfoInMarkdown += `⚠️ **Severity**: ${incident.incidentSeverity.name} \n\n`;
+    }
+
+    if (incident.monitors && incident.monitors.length > 0) {
+      feedInfoInMarkdown += `🌎 **Resources Affected**:\n`;
+
+      for (const monitor of incident.monitors) {
+        feedInfoInMarkdown += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(createdItem.projectId!, monitor.id!)).toString()})\n`;
+      }
+
+      feedInfoInMarkdown += `\n\n`;
+    }
+
+    if (createdItem.rootCause) {
+      feedInfoInMarkdown += `\n
+📄 **Root Cause**:
+
+${createdItem.rootCause || "No root cause provided."}
+
+`;
+    }
+
+    if (createdItem.remediationNotes) {
+      feedInfoInMarkdown += `\n 
+🎯 **Remediation Notes**:
+
+${createdItem.remediationNotes || "No remediation notes provided."}
+
+
+`;
+    }
+
+    const incidentCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
+      await IncidentWorkspaceMessages.getIncidentCreateMessageBlocks({
+        incidentId: createdItem.id!,
+        projectId: createdItem.projectId!,
+      });
+
+    await IncidentFeedService.createIncidentFeedItem({
+      incidentId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      incidentFeedEventType: IncidentFeedEventType.IncidentCreated,
+      displayColor: Red500,
+      feedInfoInMarkdown: feedInfoInMarkdown,
       userId: createdByUserId || undefined,
+      workspaceNotification: {
+        appendMessageBlocks: incidentCreateMessageBlocks,
+        sendWorkspaceNotification: true,
+      },
     });
 
     if (!createdItem.currentIncidentStateId) {
@@ -402,26 +593,6 @@ ${createdItem.description || "No description provided."}
       },
     });
 
-    await IncidentFeedService.createIncidentFeed({
-      incidentId: createdItem.id!,
-      projectId: createdItem.projectId!,
-      incidentFeedEventType: IncidentFeedEventType.RootCause,
-      displayColor: Red500,
-      feedInfoInMarkdown: `**Root Cause**
-
-${createdItem.rootCause || "No root cause provided."}`,
-    });
-
-    await IncidentFeedService.createIncidentFeed({
-      incidentId: createdItem.id!,
-      projectId: createdItem.projectId!,
-      incidentFeedEventType: IncidentFeedEventType.RemediationNotes,
-      displayColor: Red500,
-      feedInfoInMarkdown: `**Remediation Notes**
-
-${createdItem.remediationNotes || "No remediation notes provided."}`,
-    });
-
     // add owners.
 
     if (
@@ -475,32 +646,6 @@ ${createdItem.remediationNotes || "No remediation notes provided."}`,
       }
     }
 
-    // // send message to workspaces - slack, teams,   etc.
-    // const createdChannels: {
-    //   channelsCreated: Array<WorkspaceChannel>;
-    // } | null = await this.notifyWorkspaceOnIncidentCreate({
-    //   projectId: createdItem.projectId,
-    //   incidentId: createdItem.id!,
-    //   incidentNumber: createdItem.incidentNumber!,
-    // });
-
-    // if (
-    //   createdChannels &&
-    //   createdChannels.channelsCreated &&
-    //   createdChannels.channelsCreated.length > 0
-    // ) {
-    //   // update incident with these channels.
-    //   await this.updateOneById({
-    //     id: createdItem.id!,
-    //     data: {
-    //       postUpdatesToWorkspaceChannels: createdChannels.channelsCreated,
-    //     },
-    //     props: {
-    //       isRoot: true,
-    //     },
-    //   });
-    // }
-
     return createdItem;
   }
 
@@ -681,8 +826,22 @@ ${createdItem.remediationNotes || "No remediation notes provided."}`,
 
     if (updatedItemIds.length > 0) {
       for (const incidentId of updatedItemIds) {
+        const incident: Model | null = await this.findOneById({
+          id: incidentId,
+          select: {
+            projectId: true,
+            incidentNumber: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        const projectId: ObjectID = incident!.projectId!;
+        const incidentNumber: number = incident!.incidentNumber!;
+
         let shouldAddIncidentFeed: boolean = false;
-        let feedInfoInMarkdown: string = "**Incident was updated.**";
+        let feedInfoInMarkdown: string = `**[Incident ${incidentNumber}](${(await this.getIncidentLinkInDashboard(projectId!, incidentId!)).toString()}) was updated.**`;
 
         const createdByUserId: ObjectID | undefined | null =
           onUpdate.updateBy.props.userId;
@@ -700,7 +859,7 @@ ${onUpdate.updateBy.data.title || "No title provided."}
           if (onUpdate.updateBy.data.title) {
             // add incident feed.
 
-            feedInfoInMarkdown += `\n\n**Root Cause**: 
+            feedInfoInMarkdown += `\n\n**📄 Root Cause**: 
 ${onUpdate.updateBy.data.rootCause || "No root cause provided."}
   `;
             shouldAddIncidentFeed = true;
@@ -719,7 +878,7 @@ ${onUpdate.updateBy.data.rootCause || "No root cause provided."}
         if (onUpdate.updateBy.data.remediationNotes) {
           // add incident feed.
 
-          feedInfoInMarkdown += `\n\n**Remediation Notes**: 
+          feedInfoInMarkdown += `\n\n**🎯 Remediation Notes**: 
 ${onUpdate.updateBy.data.remediationNotes || "No remediation notes provided."}
         `;
           shouldAddIncidentFeed = true;
@@ -759,7 +918,7 @@ ${onUpdate.updateBy.data.remediationNotes || "No remediation notes provided."}
           });
 
           if (labels.length > 0) {
-            feedInfoInMarkdown += `\n\n**Labels**:
+            feedInfoInMarkdown += `\n\n**🏷️ Labels**:
 
 ${labels
   .map((label: Label) => {
@@ -794,7 +953,7 @@ ${labels
             });
 
           if (incidentSeverity) {
-            feedInfoInMarkdown += `\n\n**Incident Severity**:
+            feedInfoInMarkdown += `\n\n**⚠️ Incident Severity**:
 ${incidentSeverity.name}
 `;
 
@@ -803,13 +962,16 @@ ${incidentSeverity.name}
         }
 
         if (shouldAddIncidentFeed) {
-          await IncidentFeedService.createIncidentFeed({
+          await IncidentFeedService.createIncidentFeedItem({
             incidentId: incidentId,
             projectId: onUpdate.updateBy.props.tenantId as ObjectID,
             incidentFeedEventType: IncidentFeedEventType.IncidentUpdated,
             displayColor: Gray500,
             feedInfoInMarkdown: feedInfoInMarkdown,
             userId: createdByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+            },
           });
         }
       }
@@ -1348,53 +1510,14 @@ ${incidentSeverity.name}
     });
   }
 
-  public async notifyWorkspaceOnIncidentCreate(data: {
-    projectId: ObjectID;
+  public async getWorkspaceChannelForIncident(data: {
     incidentId: ObjectID;
-    incidentNumber: number;
-  }): Promise<{
-    channelsCreated: WorkspaceChannel[];
-  } | null> {
-    try {
-      // we will notify the workspace about the incident creation with the bot tokken which is in WorkspaceProjectAuth Table.
-      return await WorkspaceNotificationRuleService.createInviteAndPostToChannelsBasedOnRules(
-        {
-          projectId: data.projectId,
-          notificationFor: {
-            incidentId: data.incidentId,
-          },
-          notificationRuleEventType: NotificationRuleEventType.Incident,
-          channelNameSiffix: data.incidentNumber.toString(),
-          messageBlocks: await this.getWorkspaceMessageBlocksForIncidentCreate({
-            incidentId: data.incidentId,
-          }),
-        },
-      );
-    } catch (err) {
-      // log the error and continue.
-      logger.error(err);
-      return null;
-    }
-  }
-
-  public async getWorkspaceMessageBlocksForIncidentCreate(data: {
-    incidentId: ObjectID;
-  }): Promise<Array<WorkspaceMessageBlock>> {
+    workspaceType?: WorkspaceType | null;
+  }): Promise<Array<NotificationRuleWorkspaceChannel>> {
     const incident: Model | null = await this.findOneById({
       id: data.incidentId,
       select: {
-        projectId: true,
-        incidentNumber: true,
-        title: true,
-        description: true,
-        incidentSeverity: {
-          name: true,
-        },
-        rootCause: true,
-        remediationNotes: true,
-        currentIncidentState: {
-          name: true,
-        },
+        postUpdatesToWorkspaceChannels: true,
       },
       props: {
         isRoot: true,
@@ -1402,76 +1525,39 @@ ${incidentSeverity.name}
     });
 
     if (!incident) {
-      throw new BadDataException("Incident not found");
-    }
-
-    const blocks: Array<WorkspaceMessageBlock> = [];
-
-    if (incident.incidentNumber) {
-      const markdownBlock1: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `**Incident #${incident.incidentNumber} Created**`,
-      };
-      blocks.push(markdownBlock1);
-    }
-
-    if (incident.title) {
-      const markdownBlock2: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `**Incident Title**:
-${incident.title}`,
-      };
-      blocks.push(markdownBlock2);
-    }
-
-    if (incident.description) {
-      const markdownBlock3: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `**Description**:
-${incident.description}`,
-      };
-      blocks.push(markdownBlock3);
+      throw new BadDataException("Incident not found.");
     }
 
-    if (incident.incidentSeverity?.name) {
-      const markdownBlock4: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `**Severity**:
-${incident.incidentSeverity.name}`,
-      };
-      blocks.push(markdownBlock4);
-    }
+    return (incident.postUpdatesToWorkspaceChannels || []).filter(
+      (channel: NotificationRuleWorkspaceChannel) => {
+        if (!data.workspaceType) {
+          return true;
+        }
 
-    if (incident.rootCause) {
-      const markdownBlock5: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `**Root Cause**:
-${incident.rootCause}`,
-      };
-      blocks.push(markdownBlock5);
-    }
+        return channel.workspaceType === data.workspaceType;
+      },
+    );
+  }
 
-    if (incident.remediationNotes) {
-      const markdownBlock6: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `**Remediation Notes**:
-${incident.remediationNotes}`,
-      };
-      blocks.push(markdownBlock6);
-    }
+  public async getIncidentNumber(data: {
+    incidentId: ObjectID;
+  }): Promise<number | null> {
+    const incident: Model | null = await this.findOneById({
+      id: data.incidentId,
+      select: {
+        incidentNumber: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
 
-    if (incident.currentIncidentState?.name) {
-      const markdownBlock7: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `**Incident State**:
-${incident.currentIncidentState.name}`,
-      };
-      blocks.push(markdownBlock7);
+    if (!incident) {
+      throw new BadDataException("Incident not found.");
     }
 
-    // TODO: Add buttons to Post Private Note, Ack Incident, Resolve Incident. etc.
-
-    return blocks as Array<WorkspaceMessageBlock>;
+    return incident.incidentNumber || null;
   }
 }
+
 export default new Service();

package/Server/Services/IncidentStateService.ts

@@ -171,6 +171,7 @@ export class Service extends DatabaseService<IncidentState> {
         isAcknowledgedState: true,
         isCreatedState: true,
         order: true,
+        name: true,
       },
       props: data.props,
     });
@@ -201,6 +202,30 @@ export class Service extends DatabaseService<IncidentState> {
     return unresolvedIncidentStates;
   }
 
+  public async getResolvedIncidentState(data: {
+    projectId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<IncidentState> {
+    const incidentStates: Array<IncidentState> =
+      await this.getAllIncidentStates({
+        projectId: data.projectId,
+        props: data.props,
+      });
+
+    const resolvedIncidentState: IncidentState | undefined =
+      incidentStates.find((incidentState: IncidentState) => {
+        return incidentState?.isResolvedState;
+      });
+
+    if (!resolvedIncidentState) {
+      throw new BadDataException(
+        "Resolved Incident State not found for this project",
+      );
+    }
+
+    return resolvedIncidentState;
+  }
+
   public async getAcknowledgedIncidentState(data: {
     projectId: ObjectID;
     props: DatabaseCommonInteractionProps;