@oneuptime/common 10.2.1 → 10.2.3

package/Server/Services/OnCallDutyPolicyScheduleService.ts

@@ -1,12 +1,18 @@
 import DatabaseService from "./DatabaseService";
 import OnCallDutyPolicyScheduleLayerService from "./OnCallDutyPolicyScheduleLayerService";
 import OnCallDutyPolicyScheduleLayerUserService from "./OnCallDutyPolicyScheduleLayerUserService";
+import OnCallDutyPolicyUserOverrideService from "./OnCallDutyPolicyUserOverrideService";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import CalendarEvent from "../../Types/Calendar/CalendarEvent";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import OneUptimeDate from "../../Types/Date";
 import ObjectID from "../../Types/ObjectID";
 import LayerUtil, { LayerProps } from "../../Types/OnCallDutyPolicy/Layer";
+import UserOverrideUtil, {
+  UserOverrideRecord,
+} from "../../Types/OnCallDutyPolicy/UserOverrideUtil";
+import OnCallDutyPolicyUserOverride from "../../Models/DatabaseModels/OnCallDutyPolicyUserOverride";
+import QueryHelper from "../Types/Database/QueryHelper";
 import OnCallDutyPolicyScheduleLayer from "../../Models/DatabaseModels/OnCallDutyPolicyScheduleLayer";
 import OnCallDutyPolicyScheduleLayerUser from "../../Models/DatabaseModels/OnCallDutyPolicyScheduleLayerUser";
 import User from "../../Models/DatabaseModels/User";
@@ -914,9 +920,11 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
     return resultReturn;
   }
 
-  private async getScheduleLayerProps(data: {
-    scheduleId: ObjectID;
-  }): Promise<Array<LayerProps>> {
+  private async getScheduleLayerProps(data: { scheduleId: ObjectID }): Promise<{
+    layerProps: Array<LayerProps>;
+    projectId: ObjectID | null;
+    scheduleUserIds: Array<ObjectID>;
+  }> {
     // get schedule layers.
 
     const scheduleId: ObjectID = data.scheduleId;
@@ -968,23 +976,34 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       });
 
     const layerProps: Array<LayerProps> = [];
+    const scheduleUserIds: Array<ObjectID> = [];
+    const seenUserIds: Set<string> = new Set<string>();
 
     for (const layer of layers) {
+      const usersForLayer: Array<User> = layerUsers
+        .filter((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
+          return (
+            layerUser.onCallDutyPolicyScheduleLayerId?.toString() ===
+            layer.id?.toString()
+          );
+        })
+        .map((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
+          return layerUser.user!;
+        })
+        .filter((user: User) => {
+          return Boolean(user);
+        });
+
+      for (const user of usersForLayer) {
+        const idStr: string = user.id?.toString() || "";
+        if (idStr && !seenUserIds.has(idStr)) {
+          seenUserIds.add(idStr);
+          scheduleUserIds.push(user.id!);
+        }
+      }
+
       layerProps.push({
-        users:
-          layerUsers
-            .filter((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
-              return (
-                layerUser.onCallDutyPolicyScheduleLayerId?.toString() ===
-                layer.id?.toString()
-              );
-            })
-            .map((layerUser: OnCallDutyPolicyScheduleLayerUser) => {
-              return layerUser.user!;
-            })
-            .filter((user: User) => {
-              return Boolean(user);
-            }) || [],
+        users: usersForLayer,
         startDateTimeOfLayer: layer.startsAt!,
         restrictionTimes: layer.restrictionTimes!,
         rotation: layer.rotation!,
@@ -992,7 +1011,65 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       });
     }
 
-    return layerProps;
+    const projectId: ObjectID | null = layers[0]?.projectId || null;
+
+    return { layerProps, projectId, scheduleUserIds };
+  }
+
+  private async fetchOverridesForSchedule(data: {
+    projectId: ObjectID;
+    scheduleUserIds: Array<ObjectID>;
+    windowStart: Date;
+    windowEnd: Date;
+  }): Promise<Array<UserOverrideRecord>> {
+    if (data.scheduleUserIds.length === 0) {
+      return [];
+    }
+
+    const overrides: Array<OnCallDutyPolicyUserOverride> =
+      await OnCallDutyPolicyUserOverrideService.findBy({
+        query: {
+          projectId: data.projectId,
+          startsAt: QueryHelper.lessThanEqualTo(data.windowEnd),
+          endsAt: QueryHelper.greaterThanEqualTo(data.windowStart),
+        },
+        select: {
+          startsAt: true,
+          endsAt: true,
+          overrideUserId: true,
+          routeAlertsToUserId: true,
+          onCallDutyPolicyId: true,
+        },
+        sort: {
+          startsAt: SortOrder.Ascending,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    const scheduleUserIdSet: Set<string> = new Set<string>(
+      data.scheduleUserIds.map((id: ObjectID) => {
+        return id.toString();
+      }),
+    );
+
+    return overrides
+      .filter((o: OnCallDutyPolicyUserOverride) => {
+        const overrideUserId: string = o.overrideUserId?.toString() || "";
+        return scheduleUserIdSet.has(overrideUserId);
+      })
+      .map((o: OnCallDutyPolicyUserOverride): UserOverrideRecord => {
+        return {
+          overrideUserId: o.overrideUserId?.toString() || "",
+          routeAlertsToUserId: o.routeAlertsToUserId?.toString() || "",
+          startsAt: o.startsAt!,
+          endsAt: o.endsAt!,
+          onCallDutyPolicyId: o.onCallDutyPolicyId?.toString() || null,
+        };
+      });
   }
 
   public async getEventByIndexInSchedule(data: {
@@ -1006,9 +1083,10 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       } as LogAttributes,
     );
 
-    const layerProps: Array<LayerProps> = await this.getScheduleLayerProps({
-      scheduleId: data.scheduleId,
-    });
+    const { layerProps, projectId, scheduleUserIds } =
+      await this.getScheduleLayerProps({
+        scheduleId: data.scheduleId,
+      });
 
     logger.debug("Layer properties fetched: " + JSON.stringify(layerProps), {
       onCallDutyPolicyScheduleId: data.scheduleId.toString(),
@@ -1042,7 +1120,7 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       onCallDutyPolicyScheduleId: data.scheduleId.toString(),
     } as LogAttributes);
 
-    const events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
+    let events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
       {
         layers: layerProps,
         calendarStartDate: currentStartTime,
@@ -1053,6 +1131,23 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       },
     );
 
+    if (projectId && events.length > 0) {
+      const overrides: Array<UserOverrideRecord> =
+        await this.fetchOverridesForSchedule({
+          projectId,
+          scheduleUserIds,
+          windowStart: currentStartTime,
+          windowEnd: currentEndTime,
+        });
+
+      if (overrides.length > 0) {
+        events = UserOverrideUtil.applyOverridesToEvents({
+          events,
+          overrides,
+        });
+      }
+    }
+
     logger.debug("Events fetched: " + JSON.stringify(events), {
       onCallDutyPolicyScheduleId: data.scheduleId.toString(),
     } as LogAttributes);
@@ -1064,9 +1159,10 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
   public async getCurrentUserIdInSchedule(
     scheduleId: ObjectID,
   ): Promise<ObjectID | null> {
-    const layerProps: Array<LayerProps> = await this.getScheduleLayerProps({
-      scheduleId: scheduleId,
-    });
+    const { layerProps, projectId, scheduleUserIds } =
+      await this.getScheduleLayerProps({
+        scheduleId: scheduleId,
+      });
 
     if (layerProps.length === 0) {
       return null;
@@ -1078,7 +1174,7 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       1,
     );
 
-    const events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
+    let events: Array<CalendarEvent> = this.layerUtil.getMultiLayerEvents(
       {
         layers: layerProps,
         calendarStartDate: currentStartTime,
@@ -1089,6 +1185,23 @@ export class Service extends DatabaseService<OnCallDutyPolicySchedule> {
       },
     );
 
+    if (projectId && events.length > 0) {
+      const overrides: Array<UserOverrideRecord> =
+        await this.fetchOverridesForSchedule({
+          projectId,
+          scheduleUserIds,
+          windowStart: currentStartTime,
+          windowEnd: currentEndTime,
+        });
+
+      if (overrides.length > 0) {
+        events = UserOverrideUtil.applyOverridesToEvents({
+          events,
+          overrides,
+        });
+      }
+    }
+
     const currentEvent: CalendarEvent | null = events[0] || null;
 
     if (!currentEvent) {

package/Server/Services/ProjectOidcService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/ProjectOidc";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();

package/Server/Services/UserNotificationRuleService.ts

@@ -10,6 +10,7 @@ import MailService from "./MailService";
 import ShortLinkService from "./ShortLinkService";
 import SmsService from "./SmsService";
 import TelegramService from "./TelegramService";
+import WebhookService from "./WebhookService";
 import WhatsAppService from "./WhatsAppService";
 import UserEmailService from "./UserEmailService";
 import UserOnCallLogService from "./UserOnCallLogService";
@@ -28,6 +29,7 @@ import Email from "../../Types/Email";
 import EmailMessage from "../../Types/Email/EmailMessage";
 import EmailTemplateType from "../../Types/Email/EmailTemplateType";
 import BadDataException from "../../Types/Exception/BadDataException";
+import { JSONObject } from "../../Types/JSON";
 import NotificationRuleType from "../../Types/NotificationRule/NotificationRuleType";
 import ObjectID from "../../Types/ObjectID";
 import PushDeviceType from "../../Types/PushNotification/PushDeviceType";
@@ -78,6 +80,7 @@ export interface NotificationMethodDescriptor {
   userWhatsAppId?: ObjectID;
   userTelegramId?: ObjectID;
   userPushId?: ObjectID;
+  userWebhookId?: ObjectID;
 }
 
 export class Service extends DatabaseService<Model> {
@@ -173,6 +176,11 @@ export class Service extends DatabaseService<Model> {
           telegramUserHandle: true,
           isVerified: true,
         },
+        userWebhook: {
+          webhookUrl: true,
+          name: true,
+          secret: true,
+        },
         userEmail: {
           email: true,
           isVerified: true,
@@ -1082,6 +1090,202 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
+    // send webhook.
+    if (notificationRuleItem.userWebhook?.webhookUrl) {
+      const webhookUrl: string = notificationRuleItem.userWebhook.webhookUrl;
+      const webhookSecret: string | undefined =
+        notificationRuleItem.userWebhook.secret;
+      const userWebhookId: ObjectID = notificationRuleItem.userWebhook.id!;
+
+      const dispatchWebhook: (params: {
+        eventType: string;
+        payload: JSONObject;
+        entityId?: ObjectID;
+        entityKind: "alert" | "incident" | "alertEpisode" | "incidentEpisode";
+      }) => Promise<void> = async (params: {
+        eventType: string;
+        payload: JSONObject;
+        entityId?: ObjectID;
+        entityKind: "alert" | "incident" | "alertEpisode" | "incidentEpisode";
+      }): Promise<void> => {
+        logTimelineItem.status = UserNotificationStatus.Sending;
+        logTimelineItem.statusMessage = `Sending webhook to ${webhookUrl}.`;
+        logTimelineItem.userWebhookId = userWebhookId;
+
+        const updatedLog: UserOnCallLogTimeline =
+          await UserOnCallLogTimelineService.create({
+            data: logTimelineItem,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const callbacksByKind: {
+          alert?: { alertId?: ObjectID };
+          incident?: { incidentId?: ObjectID };
+        } = {};
+        if (params.entityKind === "alert" && params.entityId) {
+          callbacksByKind.alert = { alertId: params.entityId };
+        } else if (params.entityKind === "incident" && params.entityId) {
+          callbacksByKind.incident = { incidentId: params.entityId };
+        }
+
+        WebhookService.sendWebhook(
+          {
+            url: webhookUrl,
+            eventType: params.eventType,
+            payload: params.payload,
+            secret: webhookSecret,
+          },
+          {
+            projectId: options.projectId,
+            userOnCallLogTimelineId: updatedLog.id!,
+            userId: notificationRuleItem.userId!,
+            onCallPolicyId: options.onCallPolicyId,
+            onCallPolicyEscalationRuleId: options.onCallPolicyEscalationRuleId,
+            teamId: options.userBelongsToTeamId,
+            onCallDutyPolicyExecutionLogTimelineId:
+              options.onCallDutyPolicyExecutionLogTimelineId,
+            onCallScheduleId: options.onCallScheduleId,
+            ...callbacksByKind.alert,
+            ...callbacksByKind.incident,
+          },
+        ).catch(async (err: Error) => {
+          await UserOnCallLogTimelineService.updateOneById({
+            id: updatedLog.id!,
+            data: {
+              status: UserNotificationStatus.Error,
+              statusMessage: err.message || "Error sending webhook.",
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+        });
+      };
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertCreated &&
+        alert
+      ) {
+        await dispatchWebhook({
+          eventType: "on-call.alert.created",
+          entityKind: "alert",
+          entityId: alert.id!,
+          payload: {
+            eventType: "on-call.alert.created",
+            timestamp: new Date().toISOString(),
+            projectId: alert.projectId?.toString() || "",
+            userId: notificationRuleItem.userId!.toString(),
+            alert: {
+              id: alert.id?.toString() || "",
+              title: alert.title || "",
+              description: alert.description || "",
+              alertNumber: alert.alertNumber || null,
+              alertNumberWithPrefix: alert.alertNumberWithPrefix || null,
+              severity: alert.alertSeverity?.name || null,
+              state: alert.currentAlertState?.name || null,
+            },
+            onCallPolicyId: options.onCallPolicyId?.toString() || null,
+            onCallPolicyEscalationRuleId:
+              options.onCallPolicyEscalationRuleId?.toString() || null,
+          },
+        });
+      }
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.IncidentCreated &&
+        incident
+      ) {
+        await dispatchWebhook({
+          eventType: "on-call.incident.created",
+          entityKind: "incident",
+          entityId: incident.id!,
+          payload: {
+            eventType: "on-call.incident.created",
+            timestamp: new Date().toISOString(),
+            projectId: incident.projectId?.toString() || "",
+            userId: notificationRuleItem.userId!.toString(),
+            incident: {
+              id: incident.id?.toString() || "",
+              title: incident.title || "",
+              description: incident.description || "",
+              incidentNumber: incident.incidentNumber || null,
+              incidentNumberWithPrefix:
+                incident.incidentNumberWithPrefix || null,
+              severity: incident.incidentSeverity?.name || null,
+              state: incident.currentIncidentState?.name || null,
+            },
+            onCallPolicyId: options.onCallPolicyId?.toString() || null,
+            onCallPolicyEscalationRuleId:
+              options.onCallPolicyEscalationRuleId?.toString() || null,
+          },
+        });
+      }
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.AlertEpisodeCreated &&
+        alertEpisode
+      ) {
+        await dispatchWebhook({
+          eventType: "on-call.alertEpisode.created",
+          entityKind: "alertEpisode",
+          payload: {
+            eventType: "on-call.alertEpisode.created",
+            timestamp: new Date().toISOString(),
+            projectId: alertEpisode.projectId?.toString() || "",
+            userId: notificationRuleItem.userId!.toString(),
+            alertEpisode: {
+              id: alertEpisode.id?.toString() || "",
+              title: alertEpisode.title || "",
+              description: alertEpisode.description || "",
+              episodeNumber: alertEpisode.episodeNumber || null,
+              episodeNumberWithPrefix:
+                alertEpisode.episodeNumberWithPrefix || null,
+              severity: alertEpisode.alertSeverity?.name || null,
+              state: alertEpisode.currentAlertState?.name || null,
+            },
+            onCallPolicyId: options.onCallPolicyId?.toString() || null,
+            onCallPolicyEscalationRuleId:
+              options.onCallPolicyEscalationRuleId?.toString() || null,
+          },
+        });
+      }
+
+      if (
+        options.userNotificationEventType ===
+          UserNotificationEventType.IncidentEpisodeCreated &&
+        incidentEpisode
+      ) {
+        await dispatchWebhook({
+          eventType: "on-call.incidentEpisode.created",
+          entityKind: "incidentEpisode",
+          payload: {
+            eventType: "on-call.incidentEpisode.created",
+            timestamp: new Date().toISOString(),
+            projectId: incidentEpisode.projectId?.toString() || "",
+            userId: notificationRuleItem.userId!.toString(),
+            incidentEpisode: {
+              id: incidentEpisode.id?.toString() || "",
+              title: incidentEpisode.title || "",
+              description: incidentEpisode.description || "",
+              episodeNumber: incidentEpisode.episodeNumber || null,
+              episodeNumberWithPrefix:
+                incidentEpisode.episodeNumberWithPrefix || null,
+              severity: incidentEpisode.incidentSeverity?.name || null,
+              state: incidentEpisode.currentIncidentState?.name || null,
+            },
+            onCallPolicyId: options.onCallPolicyId?.toString() || null,
+            onCallPolicyEscalationRuleId:
+              options.onCallPolicyEscalationRuleId?.toString() || null,
+          },
+        });
+      }
+    }
+
     // send call.
     if (
       notificationRuleItem.userCall?.phone &&
@@ -2631,12 +2835,14 @@ export class Service extends DatabaseService<Model> {
       !createBy.data.userWhatsAppId &&
       !createBy.data.userTelegram &&
       !createBy.data.userTelegramId &&
+      !createBy.data.userWebhook &&
+      !createBy.data.userWebhookId &&
       !createBy.data.userEmailId &&
       !createBy.data.userPushId &&
       !createBy.data.userPush
     ) {
       throw new BadDataException(
-        "Call, SMS, WhatsApp, Telegram, Email, or Push notification is required",
+        "Call, SMS, WhatsApp, Telegram, Webhook, Email, or Push notification is required",
       );
     }
 
@@ -2701,6 +2907,9 @@ export class Service extends DatabaseService<Model> {
     if (descriptor.userTelegramId) {
       rule.userTelegramId = descriptor.userTelegramId;
     }
+    if (descriptor.userWebhookId) {
+      rule.userWebhookId = descriptor.userWebhookId;
+    }
     if (descriptor.userPushId) {
       rule.userPushId = descriptor.userPushId;
     }
@@ -2725,6 +2934,9 @@ export class Service extends DatabaseService<Model> {
     if (descriptor.userTelegramId) {
       query["userTelegramId"] = descriptor.userTelegramId;
     }
+    if (descriptor.userWebhookId) {
+      query["userWebhookId"] = descriptor.userWebhookId;
+    }
     if (descriptor.userPushId) {
       query["userPushId"] = descriptor.userPushId;
     }

package/Server/Services/UserNotificationSettingService.ts

@@ -12,7 +12,9 @@ import UserEmailService from "./UserEmailService";
 import UserSmsService from "./UserSmsService";
 import PushNotificationService from "./PushNotificationService";
 import UserTelegramService from "./UserTelegramService";
+import UserWebhookService from "./UserWebhookService";
 import UserWhatsAppService from "./UserWhatsAppService";
+import WebhookService from "./WebhookService";
 import WhatsAppService from "./WhatsAppService";
 import { CallRequestMessage } from "../../Types/Call/CallRequest";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
@@ -29,11 +31,13 @@ import TelegramMessage, {
 import WhatsAppMessage, {
   WhatsAppMessagePayload,
 } from "../../Types/WhatsApp/WhatsAppMessage";
+import { JSONObject } from "../../Types/JSON";
 import UserCall from "../../Models/DatabaseModels/UserCall";
 import UserEmail from "../../Models/DatabaseModels/UserEmail";
 import UserNotificationSetting from "../../Models/DatabaseModels/UserNotificationSetting";
 import UserSMS from "../../Models/DatabaseModels/UserSMS";
 import UserTelegram from "../../Models/DatabaseModels/UserTelegram";
+import UserWebhook from "../../Models/DatabaseModels/UserWebhook";
 import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { appendRecipientToWhatsAppMessage } from "../Utils/WhatsAppTemplateUtil";
@@ -89,6 +93,7 @@ export class Service extends DatabaseService<UserNotificationSetting> {
           alertByTelegram: true,
           alertByCall: true,
           alertByPush: true,
+          alertByWebhook: true,
         },
         props: {
           isRoot: true,
@@ -425,6 +430,96 @@ export class Service extends DatabaseService<UserNotificationSetting> {
           logger.error(err);
         });
       }
+
+      if (notificationSettings.alertByWebhook) {
+        const userWebhooks: Array<UserWebhook> =
+          await UserWebhookService.findBy({
+            query: {
+              userId: data.userId,
+              projectId: data.projectId,
+            },
+            select: {
+              webhookUrl: true,
+              secret: true,
+              name: true,
+            },
+            limit: LIMIT_PER_PROJECT,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+
+        const webhookPayload: JSONObject = {
+          eventType: data.eventType,
+          timestamp: new Date().toISOString(),
+          projectId: data.projectId.toString(),
+          userId: data.userId.toString(),
+          subject: data.emailEnvelope?.subject || "",
+          message: data.smsMessage?.message || "",
+        };
+
+        if (data.incidentId) {
+          webhookPayload["incidentId"] = data.incidentId.toString();
+        }
+        if (data.alertId) {
+          webhookPayload["alertId"] = data.alertId.toString();
+        }
+        if (data.monitorId) {
+          webhookPayload["monitorId"] = data.monitorId.toString();
+        }
+        if (data.scheduledMaintenanceId) {
+          webhookPayload["scheduledMaintenanceId"] =
+            data.scheduledMaintenanceId.toString();
+        }
+        if (data.statusPageId) {
+          webhookPayload["statusPageId"] = data.statusPageId.toString();
+        }
+        if (data.statusPageAnnouncementId) {
+          webhookPayload["statusPageAnnouncementId"] =
+            data.statusPageAnnouncementId.toString();
+        }
+        if (data.onCallPolicyId) {
+          webhookPayload["onCallPolicyId"] = data.onCallPolicyId.toString();
+        }
+        if (data.onCallPolicyEscalationRuleId) {
+          webhookPayload["onCallPolicyEscalationRuleId"] =
+            data.onCallPolicyEscalationRuleId.toString();
+        }
+
+        for (const userWebhook of userWebhooks) {
+          if (!userWebhook.webhookUrl) {
+            continue;
+          }
+
+          WebhookService.sendWebhook(
+            {
+              url: userWebhook.webhookUrl,
+              eventType: data.eventType,
+              payload: webhookPayload,
+              secret: userWebhook.secret,
+            },
+            {
+              projectId: data.projectId,
+              incidentId: data.incidentId,
+              alertId: data.alertId,
+              monitorId: data.monitorId,
+              scheduledMaintenanceId: data.scheduledMaintenanceId,
+              statusPageId: data.statusPageId,
+              statusPageAnnouncementId: data.statusPageAnnouncementId,
+              userId: data.userId,
+              teamId: data.teamId,
+              onCallPolicyId: data.onCallPolicyId,
+              onCallPolicyEscalationRuleId: data.onCallPolicyEscalationRuleId,
+              onCallDutyPolicyExecutionLogTimelineId:
+                data.onCallDutyPolicyExecutionLogTimelineId,
+              onCallScheduleId: data.onCallScheduleId,
+            },
+          ).catch((err: Error) => {
+            logger.error(err);
+          });
+        }
+      }
     }
   }