@oneuptime/common 7.0.3786 → 7.0.3822

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.

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -408,6 +408,12 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
     notificationRules: Array<WorkspaceNotificationRule>;
     userIds: Array<ObjectID>;
   }): Promise<void> {
+    // if no rules then return.
+    if (data.notificationRules.length === 0) {
+      logger.debug("No notification rules found. Returning.");
+      return;
+    }
+
     logger.debug(
       "inviteUsersBasedOnRulesAndWorkspaceChannels called with data:",
     );
@@ -555,6 +561,12 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
     notificationRules: Array<WorkspaceNotificationRule>;
     teamIds: Array<ObjectID>;
   }): Promise<void> {
+    // if no rules then return.
+    if (data.notificationRules.length === 0) {
+      logger.debug("No notification rules found. Returning.");
+      return;
+    }
+
     const usersInTeam: Array<User> = await TeamMemberService.getUsersInTeams(
       data.teamIds,
     );

package/Server/Utils/Workspace/MicrosoftTeams/Actions/ActionTypes.ts

@@ -0,0 +1,38 @@
+enum SlackActionType {
+  // Incident actions
+  AcknowledgeIncident = "AcknowledgeIncident",
+  ResolveIncident = "ResolveIncident",
+  ViewAddIncidentNote = "ViewAddIncidentNote",
+  SubmitIncidentNote = "SubmitIncidentNote",
+  ViewChangeIncidentState = "ViewChangeIncidentState",
+  SubmitChangeIncidentState = "SubmitChangeIncidentState",
+  ViewExecuteIncidentOnCallPolicy = "ViewExecuteIncidentOnCallPolicy",
+  SubmitExecuteIncidentOnCallPolicy = "SubmitExecuteIncidentOnCallPolicy",
+  ViewIncident = "ViewIncident",
+  NewIncident = "/incident", // new incident slash command
+  SubmitNewIncident = "SubmitNewIncident",
+
+  // Alert Actions just like Incident Actions
+  AcknowledgeAlert = "AcknowledgeAlert",
+  ResolveAlert = "ResolveAlert",
+  ViewAddAlertNote = "ViewAddAlertNote",
+  SubmitAlertNote = "SubmitAlertNote",
+  ViewChangeAlertState = "ViewChangeAlertState",
+  SubmitChangeAlertState = "SubmitChangeAlertState",
+  ViewExecuteAlertOnCallPolicy = "ViewExecuteAlertOnCallPolicy",
+  SubmitExecuteAlertOnCallPolicy = "SubmitExecuteAlertOnCallPolicy",
+  ViewAlert = "ViewAlert",
+
+  // Scheduled Maintenance Actions just like Incident Actions.
+  MarkScheduledMaintenanceAsComplete = "MarkScheduledMaintenanceAsComplete",
+  MarkScheduledMaintenanceAsOngoing = "MarkScheduledMaintenanceAsOngoing",
+  ViewAddScheduledMaintenanceNote = "ViewAddScheduledMaintenanceNote",
+  SubmitScheduledMaintenanceNote = "SubmitScheduledMaintenanceNote",
+  ViewChangeScheduledMaintenanceState = "ViewChangeScheduledMaintenanceState",
+  SubmitChangeScheduledMaintenanceState = "SubmitChangeScheduledMaintenanceState",
+  ViewScheduledMaintenance = "ViewScheduledMaintenance",
+  NewScheduledMaintenance = "/maintenance", // new scheduled maintenance slash command
+  SubmitNewScheduledMaintenance = "SubmitNewScheduledMaintenance",
+}
+
+export default SlackActionType;

package/Server/Utils/Workspace/MicrosoftTeams/Messages/Alert.ts

@@ -0,0 +1,116 @@
+import BadDataException from "../../../../../Types/Exception/BadDataException";
+import ObjectID from "../../../../../Types/ObjectID";
+import {
+  WorkspaceMessageBlock,
+  WorkspaceMessagePayloadButton,
+  WorkspacePayloadButtons,
+  WorkspacePayloadDivider,
+} from "../../../../../Types/Workspace/WorkspaceMessagePayload";
+import AlertService from "../../../../Services/AlertService";
+import MicrosoftTeamsActionType from "../../../../Utils/Workspace/MicrosoftTeams/Actions/ActionTypes";
+
+export default class MicrosoftTeamsAlertMessages {
+  public static async getAlertCreateMessageBlocks(data: {
+    alertId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<Array<WorkspaceMessageBlock>> {
+    if (!data.alertId) {
+      throw new BadDataException("Alert ID is required");
+    }
+
+    // MicrosoftTeams.
+
+    const blockMicrosoftTeams: Array<WorkspaceMessageBlock> = [];
+
+    // add divider.
+
+    const dividerBlock: WorkspacePayloadDivider = {
+      _type: "WorkspacePayloadDivider",
+    };
+
+    blockMicrosoftTeams.push(dividerBlock);
+
+    // now add buttons.
+    // View data.
+    // Execute On Call
+    // Acknowledge alert
+    // Resolve data.
+    // Change Alert State.
+    // Add Note.
+
+    const buttons: Array<WorkspaceMessagePayloadButton> = [];
+
+    // view data.
+    const viewAlertButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "🔗 View Alert",
+      url: await AlertService.getAlertLinkInDashboard(
+        data.projectId!,
+        data.alertId!,
+      ),
+      value: data.alertId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.ViewAlert,
+    };
+
+    buttons.push(viewAlertButton);
+
+    // execute on call.
+    const executeOnCallButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "📞 Execute On Call",
+      value: data.alertId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.ViewExecuteAlertOnCallPolicy,
+    };
+
+    buttons.push(executeOnCallButton);
+
+    // acknowledge data.
+    const acknowledgeAlertButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "👀 Acknowledge Alert",
+      value: data.alertId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.AcknowledgeAlert,
+    };
+
+    buttons.push(acknowledgeAlertButton);
+
+    // resolve data.
+    const resolveAlertButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "✅ Resolve Alert",
+      value: data.alertId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.ResolveAlert,
+    };
+
+    buttons.push(resolveAlertButton);
+
+    // change alert state.
+    const changeAlertStateButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "➡️ Change Alert State",
+      value: data.alertId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.ViewChangeAlertState,
+    };
+
+    buttons.push(changeAlertStateButton);
+
+    // add note.
+    const addNoteButton: WorkspaceMessagePayloadButton = {
+      _type: "WorkspaceMessagePayloadButton",
+      title: "📄 Add Note",
+      value: data.alertId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.ViewAddAlertNote,
+    };
+
+    buttons.push(addNoteButton);
+
+    const workspacePayloadButtons: WorkspacePayloadButtons = {
+      buttons: buttons,
+      _type: "WorkspacePayloadButtons",
+    };
+
+    blockMicrosoftTeams.push(workspacePayloadButtons);
+
+    return blockMicrosoftTeams;
+  }
+}

package/Server/Utils/Workspace/MicrosoftTeams/Messages/Incident.ts

@@ -1,105 +1,26 @@
-import Incident from "../../../../../Models/DatabaseModels/Incident";
 import BadDataException from "../../../../../Types/Exception/BadDataException";
+import ObjectID from "../../../../../Types/ObjectID";
 import {
   WorkspaceMessageBlock,
   WorkspaceMessagePayloadButton,
   WorkspacePayloadButtons,
   WorkspacePayloadDivider,
-  WorkspacePayloadHeader,
-  WorkspacePayloadMarkdown,
 } from "../../../../../Types/Workspace/WorkspaceMessagePayload";
 import IncidentService from "../../../../Services/IncidentService";
-import MonitorService from "../../../../Services/MonitorService";
-import SlackActionType from "../../../../Utils/Workspace/Slack/Actions/ActionTypes";
+import MicrosoftTeamsActionType from "../../../../Utils/Workspace/MicrosoftTeams/Actions/ActionTypes";
 
 export default class MicrosoftTeamsIncidentMessages {
   public static async getIncidentCreateMessageBlocks(data: {
-    incident: Incident;
+    incidentId: ObjectID;
+    projectId: ObjectID;
   }): Promise<Array<WorkspaceMessageBlock>> {
-    const incident: Incident = data.incident;
-
-    if (!incident) {
-      throw new BadDataException("Incident not found");
-    }
-
-    // Slack.
-
-    const blockSlack: Array<WorkspaceMessageBlock> = [];
-
-    if (incident.incidentNumber) {
-      const markdownBlock1: WorkspacePayloadHeader = {
-        _type: "WorkspacePayloadHeader",
-        text: `:rotating_light: **Incident #${incident.incidentNumber}**`,
-      };
-      blockSlack.push(markdownBlock1);
-    }
-
-    if (incident.title) {
-      const markdownBlock2: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `**[${incident.title}](${(await IncidentService.getIncidentLinkInDashboard(incident.projectId!, incident.id!)).toString()})**`,
-      };
-      blockSlack.push(markdownBlock2);
-    }
-
-    if (incident.description) {
-      const markdownBlock3: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `${incident.description}`,
-      };
-      blockSlack.push(markdownBlock3);
-    }
-
-    if (incident.currentIncidentState?.name) {
-      const markdownBlock7: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `:arrow_right: **Incident State**: ${incident.currentIncidentState.name}`,
-      };
-      blockSlack.push(markdownBlock7);
-    }
-
-    if (incident.incidentSeverity?.name) {
-      const markdownBlock4: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `:warning: **Severity**: ${incident.incidentSeverity.name}`,
-      };
-      blockSlack.push(markdownBlock4);
-    }
-
-    // check for monitors.
-    if (incident.monitors && incident.monitors.length > 0) {
-      let text: string = `:earth_americas: *Resources Affected*:\n`;
-
-      for (const monitor of incident.monitors) {
-        text += `- [${monitor.name}](${(await MonitorService.getMonitorLinkInDashboard(incident.projectId!, monitor.id!)).toString()})\n`;
-      }
-
-      // now add text to markdwon block.
-      const markdownBlock5: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: text,
-      };
-
-      blockSlack.push(markdownBlock5);
+    if (!data.incidentId) {
+      throw new BadDataException("Incident ID is required");
     }
 
-    if (incident.rootCause) {
-      const markdownBlock5: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `:page_facing_up: **Root Cause**:
-        ${incident.rootCause}`,
-      };
-      blockSlack.push(markdownBlock5);
-    }
+    // MicrosoftTeams.
 
-    if (incident.remediationNotes) {
-      const markdownBlock6: WorkspacePayloadMarkdown = {
-        _type: "WorkspacePayloadMarkdown",
-        text: `:dart: **Remediation Notes**:
-        ${incident.remediationNotes}`,
-      };
-      blockSlack.push(markdownBlock6);
-    }
+    const blockMicrosoftTeams: Array<WorkspaceMessageBlock> = [];
 
     // add divider.
 
@@ -107,28 +28,28 @@ export default class MicrosoftTeamsIncidentMessages {
       _type: "WorkspacePayloadDivider",
     };
 
-    blockSlack.push(dividerBlock);
+    blockMicrosoftTeams.push(dividerBlock);
 
     // now add buttons.
-    // View Incident.
+    // View data.
     // Execute On Call
     // Acknowledge incident
-    // Resolve Incident.
+    // Resolve data.
     // Change Incident State.
     // Add Note.
 
     const buttons: Array<WorkspaceMessagePayloadButton> = [];
 
-    // view incident.
+    // view data.
     const viewIncidentButton: WorkspaceMessagePayloadButton = {
       _type: "WorkspaceMessagePayloadButton",
-      title: "View Incident",
+      title: "🔗 View Incident",
       url: await IncidentService.getIncidentLinkInDashboard(
-        incident.projectId!,
-        incident.id!,
+        data.projectId!,
+        data.incidentId!,
       ),
-      value: "view_incident",
-      actionId: SlackActionType.ViewIncident,
+      value: data.incidentId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.ViewIncident,
     };
 
     buttons.push(viewIncidentButton);
@@ -136,29 +57,29 @@ export default class MicrosoftTeamsIncidentMessages {
     // execute on call.
     const executeOnCallButton: WorkspaceMessagePayloadButton = {
       _type: "WorkspaceMessagePayloadButton",
-      title: ":telephone_receiver: Execute On Call",
-      value: "execute_on_call",
-      actionId: SlackActionType.ViewExecuteIncidentOnCallPolicy,
+      title: "📞 Execute On Call",
+      value: data.incidentId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.ViewExecuteIncidentOnCallPolicy,
     };
 
     buttons.push(executeOnCallButton);
 
-    // acknowledge incident.
+    // acknowledge data.
     const acknowledgeIncidentButton: WorkspaceMessagePayloadButton = {
       _type: "WorkspaceMessagePayloadButton",
-      title: ":eyes: Acknowledge Incident",
-      value: "acknowledge_incident",
-      actionId: SlackActionType.AcknowledgeIncident,
+      title: "👀 Acknowledge Incident",
+      value: data.incidentId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.AcknowledgeIncident,
     };
 
     buttons.push(acknowledgeIncidentButton);
 
-    // resolve incident.
+    // resolve data.
     const resolveIncidentButton: WorkspaceMessagePayloadButton = {
       _type: "WorkspaceMessagePayloadButton",
-      title: ":white_check_mark: Resolve Incident",
-      value: "resolve_incident",
-      actionId: SlackActionType.ResolveIncident,
+      title: "✅ Resolve Incident",
+      value: data.incidentId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.ResolveIncident,
     };
 
     buttons.push(resolveIncidentButton);
@@ -166,9 +87,9 @@ export default class MicrosoftTeamsIncidentMessages {
     // change incident state.
     const changeIncidentStateButton: WorkspaceMessagePayloadButton = {
       _type: "WorkspaceMessagePayloadButton",
-      title: ":arrow_right: Change Incident State",
-      value: "change_incident_state",
-      actionId: SlackActionType.ViewChangeIncidentState,
+      title: "➡️ Change Incident State",
+      value: data.incidentId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.ViewChangeIncidentState,
     };
 
     buttons.push(changeIncidentStateButton);
@@ -176,9 +97,9 @@ export default class MicrosoftTeamsIncidentMessages {
     // add note.
     const addNoteButton: WorkspaceMessagePayloadButton = {
       _type: "WorkspaceMessagePayloadButton",
-      title: ":page_facing_up: Add Note",
-      value: "add_note",
-      actionId: SlackActionType.ViewAddIncidentNote,
+      title: "📄 Add Note",
+      value: data.incidentId?.toString() || "",
+      actionId: MicrosoftTeamsActionType.ViewAddIncidentNote,
     };
 
     buttons.push(addNoteButton);
@@ -188,8 +109,8 @@ export default class MicrosoftTeamsIncidentMessages {
       _type: "WorkspacePayloadButtons",
     };
 
-    blockSlack.push(workspacePayloadButtons);
+    blockMicrosoftTeams.push(workspacePayloadButtons);
 
-    return blockSlack;
+    return blockMicrosoftTeams;
   }
 }