@oneuptime/common 7.0.4007 → 7.0.4026

package/Server/Services/AlertStateTimelineService.ts

@@ -21,6 +21,8 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger from "../Utils/Logger";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 
 export class Service extends DatabaseService<AlertStateTimeline> {
   public constructor() {
@@ -336,9 +338,73 @@ ${createdItem.rootCause}`,
       logger.error(error);
     });
 
+    const isLastAlertState: boolean = await this.isLastAlertState({
+      projectId: createdItem.projectId!,
+      alertStateId: createdItem.alertStateId,
+    });
+
+    if (isLastAlertState) {
+      WorkspaceNotificationRuleService.archiveWorkspaceChannels({
+        projectId: createdItem.projectId!,
+        notificationFor: {
+          alertId: createdItem.alertId,
+        },
+        sendMessageBeforeArchiving: {
+          _type: "WorkspacePayloadMarkdown",
+          text: `**[Alert ${alertNumber}](${(
+            await AlertService.getAlertLinkInDashboard(
+              createdItem.projectId!,
+              createdItem.alertId!,
+            )
+          ).toString()})** is resolved. Archiving channel.`,
+        },
+      }).catch((error: Error) => {
+        logger.error(`Error while archiving workspace channels:`);
+        logger.error(error);
+      });
+    }
+
     return createdItem;
   }
 
+  private async isLastAlertState(data: {
+    projectId: ObjectID;
+    alertStateId: ObjectID;
+  }): Promise<boolean> {
+    // find all the states for this project and sort it by order. Then, check if this is the last state.
+    const alertStates: AlertState[] = await AlertStateService.findBy({
+      query: {
+        projectId: data.projectId,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      sort: {
+        order: SortOrder.Ascending,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const alertState: AlertState | null =
+      alertStates.find((alertState: AlertState) => {
+        return alertState.id?.toString() === data.alertStateId.toString();
+      }) || null;
+
+    if (!alertState) {
+      throw new BadDataException("Alert state not found.");
+    }
+
+    const lastAlertState: AlertState | undefined =
+      alertStates[alertStates.length - 1];
+
+    if (lastAlertState && lastAlertState.id) {
+      return lastAlertState.id.toString() === alertState.id?.toString();
+    }
+
+    return false;
+  }
+
   @CaptureSpan()
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<AlertStateTimeline>,

package/Server/Services/IncidentStateTimelineService.ts

@@ -22,6 +22,8 @@ import logger from "../Utils/Logger";
 import IncidentFeedService from "./IncidentFeedService";
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
 
 export class Service extends DatabaseService<IncidentStateTimeline> {
   public constructor() {
@@ -359,9 +361,73 @@ ${createdItem.rootCause}`,
       logger.error(error);
     });
 
+    const isLastIncidentState: boolean = await this.isLastIncidentState({
+      projectId: createdItem.projectId!,
+      incidentStateId: createdItem.incidentStateId,
+    });
+
+    if (isLastIncidentState) {
+      WorkspaceNotificationRuleService.archiveWorkspaceChannels({
+        projectId: createdItem.projectId!,
+        notificationFor: {
+          incidentId: createdItem.incidentId,
+        },
+        sendMessageBeforeArchiving: {
+          _type: "WorkspacePayloadMarkdown",
+          text: `**[Incident ${incidentNumber}](${(
+            await IncidentService.getIncidentLinkInDashboard(
+              createdItem.projectId!,
+              createdItem.incidentId!,
+            )
+          ).toString()})** is resolved. Archiving channel.`,
+        },
+      }).catch((error: Error) => {
+        logger.error(`Error while archiving workspace channels:`);
+        logger.error(error);
+      });
+    }
+
     return createdItem;
   }
 
+  private async isLastIncidentState(data: {
+    projectId: ObjectID;
+    incidentStateId: ObjectID;
+  }): Promise<boolean> {
+    // find all the states for this project and sort it by order. Then, check if this is the last state.
+    const incidentStates: IncidentState[] = await IncidentStateService.findBy({
+      query: {
+        projectId: data.projectId,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      sort: {
+        order: SortOrder.Ascending,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const incidentState: IncidentState | null =
+      incidentStates.find((incidentState: IncidentState) => {
+        return incidentState.id?.toString() === data.incidentStateId.toString();
+      }) || null;
+
+    if (!incidentState) {
+      throw new BadDataException("Incident state not found.");
+    }
+
+    const lastIncidentState: IncidentState | undefined =
+      incidentStates[incidentStates.length - 1];
+
+    if (lastIncidentState && lastIncidentState.id) {
+      return lastIncidentState.id.toString() === incidentState.id?.toString();
+    }
+
+    return false;
+  }
+
   @CaptureSpan()
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<IncidentStateTimeline>,

package/Server/Services/MonitorService.ts

@@ -56,12 +56,17 @@ import Label from "../../Models/DatabaseModels/Label";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
-import { MessageBlocksByWorkspaceType } from "./WorkspaceNotificationRuleService";
+import WorkspaceNotificationRuleService, {
+  MessageBlocksByWorkspaceType,
+} from "./WorkspaceNotificationRuleService";
 import MonitorWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/Monitor";
 import MonitorFeedService from "./MonitorFeedService";
 import { MonitorFeedEventType } from "../../Models/DatabaseModels/MonitorFeed";
 import { Gray500, Green500 } from "../../Types/BrandColors";
 import LabelService from "./LabelService";
+import QueryOperator from "../../Types/BaseDatabase/QueryOperator";
+import { FindWhere } from "../../Types/BaseDatabase/Query";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -85,6 +90,49 @@ export class Service extends DatabaseService<Model> {
           isRoot: true,
         },
       });
+
+      let projectId: FindWhere<ObjectID> | QueryOperator<ObjectID> | undefined =
+        deleteBy.query.projectId || deleteBy.props.tenantId;
+
+      if (!projectId) {
+        // fetch this monitor from the database to get the projectId.
+        const monitor: Model | null = await this.findOneById({
+          id: new ObjectID(deleteBy.query._id as string) as ObjectID,
+          select: {
+            projectId: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+        if (!monitor) {
+          throw new BadDataException("Monitor not found.");
+        }
+
+        if (!monitor.id) {
+          throw new BadDataException("Monitor id not found.");
+        }
+
+        projectId = monitor.projectId!;
+      }
+
+      try {
+        await WorkspaceNotificationRuleService.archiveWorkspaceChannels({
+          projectId: projectId as ObjectID,
+          notificationFor: {
+            monitorId: new ObjectID(deleteBy.query._id as string) as ObjectID,
+          },
+          sendMessageBeforeArchiving: {
+            _type: "WorkspacePayloadMarkdown",
+            text: `🗑️ This monitor is deleted. The channel is being archived.`,
+          },
+        });
+      } catch (error) {
+        logger.error(
+          `Error while archiving workspace channels for monitor ${deleteBy.query._id}: ${error}`,
+        );
+      }
     }
 
     return { deleteBy, carryForward: null };
@@ -434,6 +482,29 @@ ${createdItem.description || "No description provided."}
       feedInfoInMarkdown += `\n\n`;
     }
 
+    // send message to workspaces - slack, teams,   etc.
+    const workspaceResult: {
+      channelsCreated: Array<NotificationRuleWorkspaceChannel>;
+    } | null =
+      await MonitorWorkspaceMessages.createChannelsAndInviteUsersToChannels({
+        projectId: createdItem.projectId,
+        monitorId: createdItem.id!,
+        monitorName: createdItem.name!,
+      });
+
+    if (workspaceResult && workspaceResult.channelsCreated?.length > 0) {
+      // update incident with these channels.
+      await this.updateOneById({
+        id: createdItem.id!,
+        data: {
+          postUpdatesToWorkspaceChannels: workspaceResult.channelsCreated || [],
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
     const monitorCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
       await MonitorWorkspaceMessages.getMonitorCreateMessageBlocks({
         monitorId: createdItem.id!,

package/Server/Services/OnCallDutyPolicyEscalationRuleScheduleService.ts

@@ -1,10 +1,253 @@
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/OnCallDutyPolicyEscalationRuleSchedule";
+import Dictionary from "../../Types/Dictionary";
+import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
+import EmailTemplateType from "../../Types/Email/EmailTemplateType";
+import { EmailEnvelope } from "../../Types/Email/EmailMessage";
+import { SMSMessage } from "../../Types/SMS/SMS";
+import UserNotificationSettingService from "./UserNotificationSettingService";
+import NotificationSettingEventType from "../../Types/NotificationSetting/NotificationSettingEventType";
+import { CallRequestMessage } from "../../Types/Call/CallRequest";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import OnCallDutyPolicyScheduleService from "./OnCallDutyPolicyScheduleService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const createdItemId: ObjectID = createdItem.id!;
+
+    if (!createdItemId) {
+      throw new BadDataException("Created item does not have an ID");
+    }
+
+    const createdModel: Model | null = await this.findOneById({
+      id: createdItemId,
+      select: {
+        projectId: true,
+        onCallDutyPolicyScheduleId: true,
+        onCallDutyPolicySchedule: {
+          name: true,
+        },
+        onCallDutyPolicyEscalationRule: {
+          name: true,
+          _id: true,
+          order: true,
+        },
+        onCallDutyPolicy: {
+          name: true,
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!createdModel) {
+      throw new BadDataException("Created item does not have an ID");
+    }
+
+    if (!createdModel.onCallDutyPolicyScheduleId) {
+      throw new BadDataException(
+        "Created item does not have a onCallDutyPolicyScheduleId",
+      );
+    }
+
+    // send notification to the new current user.
+
+    const userOnSchedule: ObjectID | null =
+      await OnCallDutyPolicyScheduleService.getCurrentUserIdInSchedule(
+        createdModel.onCallDutyPolicyScheduleId,
+      );
+
+    if (!userOnSchedule) {
+      return createdItem;
+    }
+
+    const scheduleName: string =
+      createdModel.onCallDutyPolicySchedule?.name || "No name provided";
+
+    const sendEmailToUserId: ObjectID | undefined | null = userOnSchedule;
+
+    if (!sendEmailToUserId) {
+      return createdItem;
+    }
+
+    if (!createdModel) {
+      return createdItem;
+    }
+
+    const vars: Dictionary<string> = {
+      onCallPolicyName:
+        createdModel.onCallDutyPolicy?.name || "No name provided",
+      escalationRuleName:
+        createdModel.onCallDutyPolicyEscalationRule?.name || "No name provided",
+      escalationRuleOrder:
+        createdModel.onCallDutyPolicyEscalationRule?.order?.toString() ||
+        "No order provided",
+      reason: "You are currently on roster for schedule " + scheduleName,
+      onCallPolicyViewLink: (
+        await OnCallDutyPolicyService.getOnCallPolicyLinkInDashboard(
+          createdModel!.projectId!,
+          createdModel.onCallDutyPolicy!.id!,
+        )
+      ).toString(),
+    };
+
+    // Notify the current user about being added to the schedule.
+    const emailMessage: EmailEnvelope = {
+      templateType: EmailTemplateType.UserAddedToOnCallPolicy,
+      vars: vars,
+      subject: `You have been added to the on-call duty policy ${createdModel.onCallDutyPolicy?.name} for schedule ${scheduleName}`,
+    };
+
+    const sms: SMSMessage = {
+      message: `This is a message from OneUptime. You have been added to the on-call duty policy ${createdModel.onCallDutyPolicy?.name} for schedule ${scheduleName} and escalation rule ${createdModel.onCallDutyPolicyEscalationRule?.name} with order ${createdModel.onCallDutyPolicyEscalationRule?.order}. To unsubscribe from this notification, go to User Settings in the OneUptime Dashboard.`,
+    };
+
+    const callMessage: CallRequestMessage = {
+      data: [
+        {
+          sayMessage: `This is a message from OneUptime. You have been added to the on-call duty policy ${createdModel.onCallDutyPolicy?.name} for schedule ${scheduleName} and escalation rule ${createdModel.onCallDutyPolicyEscalationRule?.name} with order ${createdModel.onCallDutyPolicyEscalationRule?.order}. To unsubscribe from this notification, go to User Settings in the OneUptime Dashboard. Goodbye.`,
+        },
+      ],
+    };
+
+    await UserNotificationSettingService.sendUserNotification({
+      userId: sendEmailToUserId,
+      projectId: createdModel!.projectId!,
+      emailEnvelope: emailMessage,
+      smsMessage: sms,
+      callRequestMessage: callMessage,
+      eventType:
+        NotificationSettingEventType.SEND_WHEN_USER_IS_ADDED_TO_ON_CALL_POLICY,
+    });
+
+    return createdItem;
+  }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToFetchBeforeDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        projectId: true,
+        onCallDutyPolicyScheduleId: true,
+        onCallDutyPolicySchedule: {
+          name: true,
+          _id: true,
+        },
+        onCallDutyPolicyEscalationRule: {
+          name: true,
+          _id: true,
+          order: true,
+        },
+        onCallDutyPolicy: {
+          name: true,
+          _id: true,
+        },
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+    });
+
+    return {
+      deleteBy,
+      carryForward: {
+        deletedItems: itemsToFetchBeforeDelete,
+      },
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deletedItems: Array<Model> = onDelete.carryForward.deletedItems;
+
+    for (const deletedItem of deletedItems) {
+      const userOnSchedule: ObjectID | null =
+        await OnCallDutyPolicyScheduleService.getCurrentUserIdInSchedule(
+          deletedItem.onCallDutyPolicyScheduleId!,
+        );
+
+      if (!userOnSchedule) {
+        continue;
+      }
+
+      const sendEmailToUserId: ObjectID | undefined | null = userOnSchedule;
+
+      if (!sendEmailToUserId) {
+        return onDelete;
+      }
+
+      const scheduleName: string =
+        deletedItem.onCallDutyPolicySchedule?.name || "No name provided";
+
+      const vars: Dictionary<string> = {
+        onCallPolicyName:
+          deletedItem.onCallDutyPolicy?.name || "No name provided",
+        escalationRuleName:
+          deletedItem.onCallDutyPolicyEscalationRule?.name ||
+          "No name provided",
+        escalationRuleOrder:
+          deletedItem.onCallDutyPolicyEscalationRule?.order?.toString() ||
+          "No order provided",
+        reason: `You have been removed from the on-call duty policy escalation rule for schedule ${scheduleName}.`,
+        onCallPolicyViewLink: (
+          await OnCallDutyPolicyService.getOnCallPolicyLinkInDashboard(
+            deletedItem!.projectId!,
+            deletedItem.onCallDutyPolicy!.id!,
+          )
+        ).toString(),
+      };
+
+      // Notify the current user about being removed from the schedule.
+      const emailMessage: EmailEnvelope = {
+        templateType: EmailTemplateType.UserRemovedFromOnCallPolicy,
+        vars: vars,
+        subject: `You have been removed from the on-call duty policy ${deletedItem.onCallDutyPolicy?.name} for schedule ${scheduleName}`,
+      };
+
+      const sms: SMSMessage = {
+        message: `This is a message from OneUptime. You have been removed from the on-call duty policy ${deletedItem.onCallDutyPolicy?.name} for schedule ${scheduleName} and escalation rule ${deletedItem.onCallDutyPolicyEscalationRule?.name} with order ${deletedItem.onCallDutyPolicyEscalationRule?.order}. To unsubscribe from this notification go to User Settings in OneUptime Dashboard.`,
+      };
+
+      const callMessage: CallRequestMessage = {
+        data: [
+          {
+            sayMessage: `This is a message from OneUptime. You have been removed from the on-call duty policy ${deletedItem.onCallDutyPolicy?.name} for schedule ${scheduleName} and escalation rule ${deletedItem.onCallDutyPolicyEscalationRule?.name} with order ${deletedItem.onCallDutyPolicyEscalationRule?.order}. To unsubscribe from this notification go to User Settings in OneUptime Dashboard. Good Bye`,
+          },
+        ],
+      };
+
+      await UserNotificationSettingService.sendUserNotification({
+        userId: sendEmailToUserId,
+        projectId: deletedItem!.projectId!,
+        emailEnvelope: emailMessage,
+        smsMessage: sms,
+        callRequestMessage: callMessage,
+        eventType:
+          NotificationSettingEventType.SEND_WHEN_USER_IS_REMOVED_FROM_ON_CALL_POLICY,
+      });
+    }
+
+    return onDelete;
+  }
 }
 
 export default new Service();

package/Server/Services/OnCallDutyPolicyEscalationRuleService.ts

@@ -671,6 +671,52 @@ export class Service extends DatabaseService<Model> {
         select: {
           order: true,
           onCallDutyPolicyId: true,
+          projectId: true,
+        },
+      });
+
+      if (!resource) {
+        throw new BadDataException(
+          "OnCallDutyPolicyEscalationRule with this id not found",
+        );
+      }
+
+      // delete users in escalation rule, teams in escalation rule and schedules in escalation rule.
+      await OnCallDutyPolicyEscalationRuleScheduleService.deleteBy({
+        query: {
+          onCallDutyPolicyEscalationRuleId: resource.id!,
+          projectId: resource.projectId!,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      // delete users in escalation rule.
+      await OnCallDutyPolicyEscalationRuleUserService.deleteBy({
+        query: {
+          onCallDutyPolicyEscalationRuleId: resource.id!,
+          projectId: resource.projectId!,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      // delete teams in escalation rule.
+      await OnCallDutyPolicyEscalationRuleTeamService.deleteBy({
+        query: {
+          onCallDutyPolicyEscalationRuleId: resource.id!,
+          projectId: resource.projectId!,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
         },
       });
     }