@oneuptime/common 7.0.4039 → 7.0.4064

package/Server/Services/OnCallDutyPolicyService.ts

@@ -21,14 +21,211 @@ import OnCallDutyPolicyEscalationRuleTeamService from "./OnCallDutyPolicyEscalat
 import QueryHelper from "../Types/Database/QueryHelper";
 import OnCallDutyPolicyEscalationRuleSchedule from "../../Models/DatabaseModels/OnCallDutyPolicyEscalationRuleSchedule";
 import OnCallDutyPolicyEscalationRuleScheduleService from "./OnCallDutyPolicyEscalationRuleScheduleService";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import { FindWhere } from "../../Types/BaseDatabase/Query";
+import QueryOperator from "../../Types/BaseDatabase/QueryOperator";
+import WorkspaceNotificationRuleService, {
+  MessageBlocksByWorkspaceType,
+} from "./WorkspaceNotificationRuleService";
+import logger from "../Utils/Logger";
+import OnCallDutyPolicyWorkspaceMessages from "../Utils/Workspace/WorkspaceMessages/OnCallDutyPolicy";
+import OnCallDutyPolicyFeedService from "./OnCallDutyPolicyFeedService";
+import { OnCallDutyPolicyFeedEventType } from "../../Models/DatabaseModels/OnCallDutyPolicyFeed";
+import { Green500 } from "../../Types/BrandColors";
 
 export class Service extends DatabaseService<OnCallDutyPolicy> {
   public constructor() {
     super(OnCallDutyPolicy);
   }
 
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<OnCallDutyPolicy>,
+    createdItem: OnCallDutyPolicy,
+  ): Promise<OnCallDutyPolicy> {
+    if (!createdItem.id) {
+      throw new BadDataException("On Call Policy id not found.");
+    }
+
+    const onCallPolicy: OnCallDutyPolicy | null = await this.findOneById({
+      id: createdItem.id,
+      select: {
+        projectId: true,
+        name: true,
+        description: true,
+        labels: {
+          name: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!onCallPolicy) {
+      throw new BadDataException("On Call Policy not found.");
+    }
+
+    const createdByUserId: ObjectID | undefined | null =
+      createdItem.createdByUserId || createdItem.createdByUser?.id;
+
+    let feedInfoInMarkdown: string = `#### 📞 On Call Policy Created: 
+              
+**${onCallPolicy.name || "No name provided."}**:
+    
+${onCallPolicy.description || "No description provided."}
+        
+`;
+
+    if (onCallPolicy?.labels && onCallPolicy.labels.length > 0) {
+      feedInfoInMarkdown += `🏷️ **Labels**:\n`;
+
+      for (const label of onCallPolicy.labels) {
+        feedInfoInMarkdown += `- ${label.name}\n`;
+      }
+
+      feedInfoInMarkdown += `\n\n`;
+    }
+
+    // send message to workspaces - slack, teams,   etc.
+    const workspaceResult: {
+      channelsCreated: Array<NotificationRuleWorkspaceChannel>;
+    } | null =
+      await OnCallDutyPolicyWorkspaceMessages.createChannelsAndInviteUsersToChannels(
+        {
+          projectId: onCallPolicy.projectId!,
+          onCallDutyPolicyId: onCallPolicy.id!,
+          onCallDutyPolicyName: onCallPolicy.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 onCallDutyPolicyCreateMessageBlocks: Array<MessageBlocksByWorkspaceType> =
+      await OnCallDutyPolicyWorkspaceMessages.getOnCallDutyPolicyCreateMessageBlocks(
+        {
+          onCallDutyPolicyId: createdItem.id!,
+          projectId: createdItem.projectId!,
+        },
+      );
+
+    await OnCallDutyPolicyFeedService.createOnCallDutyPolicyFeedItem({
+      onCallDutyPolicyId: createdItem.id!,
+      projectId: createdItem.projectId!,
+      onCallDutyPolicyFeedEventType:
+        OnCallDutyPolicyFeedEventType.OnCallDutyPolicyCreated,
+      displayColor: Green500,
+      feedInfoInMarkdown: feedInfoInMarkdown,
+      userId: createdByUserId || undefined,
+      workspaceNotification: {
+        appendMessageBlocks: onCallDutyPolicyCreateMessageBlocks,
+        sendWorkspaceNotification: true,
+      },
+    });
+
+    return createdItem;
+  }
+
   @CaptureSpan()
-  public async getOnCallPolicyLinkInDashboard(
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<OnCallDutyPolicy>,
+  ): Promise<OnDelete<OnCallDutyPolicy>> {
+    if (deleteBy.query._id) {
+      let projectId: FindWhere<ObjectID> | QueryOperator<ObjectID> | undefined =
+        deleteBy.query.projectId || deleteBy.props.tenantId;
+
+      if (!projectId) {
+        // fetch this onCallDutyPolicy from the database to get the projectId.
+        const onCallDutyPolicy: OnCallDutyPolicy | null =
+          await this.findOneById({
+            id: new ObjectID(deleteBy.query._id as string) as ObjectID,
+            select: {
+              projectId: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+        if (!onCallDutyPolicy) {
+          throw new BadDataException("OnCallDutyPolicy not found.");
+        }
+
+        if (!onCallDutyPolicy.id) {
+          throw new BadDataException("OnCallDutyPolicy id not found.");
+        }
+
+        projectId = onCallDutyPolicy.projectId!;
+      }
+
+      try {
+        await WorkspaceNotificationRuleService.archiveWorkspaceChannels({
+          projectId: projectId as ObjectID,
+          notificationFor: {
+            onCallDutyPolicyId: new ObjectID(
+              deleteBy.query._id as string,
+            ) as ObjectID,
+          },
+          sendMessageBeforeArchiving: {
+            _type: "WorkspacePayloadMarkdown",
+            text: `🗑️ This on-call policy is deleted. The channel is being archived.`,
+          },
+        });
+      } catch (error) {
+        logger.error(
+          `Error while archiving workspace channels for onCallDutyPolicy ${deleteBy.query._id}: ${error}`,
+        );
+      }
+    }
+
+    return { deleteBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  public async getWorkspaceChannelForOnCallDutyPolicy(data: {
+    onCallDutyPolicyId: ObjectID;
+    workspaceType?: WorkspaceType | null;
+  }): Promise<Array<NotificationRuleWorkspaceChannel>> {
+    const onCallDutyPolicy: OnCallDutyPolicy | null = await this.findOneById({
+      id: data.onCallDutyPolicyId,
+      select: {
+        postUpdatesToWorkspaceChannels: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!onCallDutyPolicy) {
+      throw new BadDataException("OnCallDutyPolicy not found.");
+    }
+
+    return (onCallDutyPolicy.postUpdatesToWorkspaceChannels || []).filter(
+      (channel: NotificationRuleWorkspaceChannel) => {
+        if (!data.workspaceType) {
+          return true;
+        }
+
+        return channel.workspaceType === data.workspaceType;
+      },
+    );
+  }
+
+  @CaptureSpan()
+  public async getOnCallDutyPolicyLinkInDashboard(
     projectId: ObjectID,
     onCallDutyPolicyId: ObjectID,
   ): Promise<URL> {
@@ -39,6 +236,27 @@ export class Service extends DatabaseService<OnCallDutyPolicy> {
     );
   }
 
+  @CaptureSpan()
+  public async getOnCallDutyPolicyName(data: {
+    onCallDutyPolicyId: ObjectID;
+  }): Promise<string | null> {
+    const { onCallDutyPolicyId } = data;
+
+    const onCallDutyPolicy: OnCallDutyPolicy | null = await this.findOneById({
+      id: onCallDutyPolicyId,
+      select: {
+        name: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return onCallDutyPolicy && onCallDutyPolicy.name
+      ? onCallDutyPolicy.name.toString()
+      : null;
+  }
+
   @CaptureSpan()
   public async executePolicy(
     policyId: ObjectID,

package/Server/Services/OnCallDutyPolicyUserOverrideService.ts

@@ -4,10 +4,18 @@ import DatabaseConfig from "../DatabaseConfig";
 import URL from "../../Types/API/URL";
 import OnCallDutyPolicyUserOverride from "../../Models/DatabaseModels/OnCallDutyPolicyUserOverride";
 import CreateBy from "../Types/Database/CreateBy";
-import { OnCreate } from "../Types/Database/Hooks";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import OnCallDutyPolicyFeedService from "./OnCallDutyPolicyFeedService";
+import { OnCallDutyPolicyFeedEventType } from "../../Models/DatabaseModels/OnCallDutyPolicyFeed";
+import { Gray500 } from "../../Types/BrandColors";
+import UserService from "./UserService";
+import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
+import Timezone from "../../Types/Timezone";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 
 export class Service extends DatabaseService<OnCallDutyPolicyUserOverride> {
   public constructor() {
@@ -54,6 +62,181 @@ export class Service extends DatabaseService<OnCallDutyPolicyUserOverride> {
     };
   }
 
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<OnCallDutyPolicyUserOverride>,
+    createdItem: OnCallDutyPolicyUserOverride,
+  ): Promise<OnCallDutyPolicyUserOverride> {
+    // add to on call feed.
+    const onCallDutyPolicyId: ObjectID | undefined | null =
+      createdItem.onCallDutyPolicyId || createdItem.onCallDutyPolicy?.id;
+
+    const projectId: ObjectID | undefined | null =
+      createdItem.projectId || createdItem.project?.id;
+
+    const overrideUserId: ObjectID | undefined | null =
+      createdItem.overrideUserId || createdItem.overrideUser?.id;
+
+    const routeAlertsToUserId: ObjectID | undefined | null =
+      createdItem.routeAlertsToUserId || createdItem.routeAlertsToUser?.id;
+
+    if (
+      onCallDutyPolicyId &&
+      projectId &&
+      overrideUserId &&
+      routeAlertsToUserId
+    ) {
+      const onCallPolicyName: string | null =
+        await OnCallDutyPolicyService.getOnCallDutyPolicyName({
+          onCallDutyPolicyId: onCallDutyPolicyId,
+        });
+
+      const overrideUserTimezone: Timezone | null =
+        await UserService.getTimezoneForUser(overrideUserId);
+
+      const routeAlertsToUserTimezone: Timezone | null =
+        await UserService.getTimezoneForUser(routeAlertsToUserId);
+
+      const timezones: Timezone[] = [];
+      if (overrideUserTimezone) {
+        timezones.push(overrideUserTimezone);
+      }
+
+      if (routeAlertsToUserTimezone) {
+        timezones.push(routeAlertsToUserTimezone);
+      }
+
+      await OnCallDutyPolicyFeedService.createOnCallDutyPolicyFeedItem({
+        onCallDutyPolicyId: onCallDutyPolicyId,
+        projectId: projectId!,
+        onCallDutyPolicyFeedEventType:
+          OnCallDutyPolicyFeedEventType.UserOverrideAdded,
+        displayColor: Gray500,
+        feedInfoInMarkdown: `🔁 Added a User Override Rule for user **${await UserService.getUserMarkdownString(
+          {
+            userId: overrideUserId,
+            projectId: projectId!,
+          },
+        )}** for the [On-Call Policy ${onCallPolicyName}](${(await OnCallDutyPolicyService.getOnCallDutyPolicyLinkInDashboard(projectId!, onCallDutyPolicyId!)).toString()}). All alerts will be routed to **${await UserService.getUserMarkdownString(
+          {
+            userId: routeAlertsToUserId,
+            projectId: projectId!,
+          },
+        )}** from **${OneUptimeDate.getDateAsFormattedStringInMultipleTimezones(
+          {
+            date: createdItem.startsAt!,
+            timezones: timezones,
+          },
+        )}**  to **${OneUptimeDate.getDateAsFormattedStringInMultipleTimezones({
+          date: createdItem.endsAt!,
+          timezones: timezones,
+        })}**. `,
+
+        userId: createdItem.createdByUserId! || undefined,
+        workspaceNotification: {
+          sendWorkspaceNotification: true,
+          notifyUserId: createdItem.createdByUserId! || undefined,
+        },
+      });
+    }
+
+    return createdItem;
+  }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<OnCallDutyPolicyUserOverride>,
+  ): Promise<OnDelete<OnCallDutyPolicyUserOverride>> {
+    const itemsToDelete: OnCallDutyPolicyUserOverride[] = await this.findBy({
+      query: deleteBy.query,
+      select: {
+        onCallDutyPolicyId: true,
+        projectId: true,
+        overrideUserId: true,
+        routeAlertsToUserId: true,
+        startsAt: true,
+        endsAt: true,
+        createdByUserId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+      skip: 0,
+      limit: LIMIT_PER_PROJECT,
+    });
+
+    for (const item of itemsToDelete) {
+      const onCallDutyPolicyId: ObjectID | undefined | null =
+        item.onCallDutyPolicyId || item.onCallDutyPolicy?.id;
+
+      const projectId: ObjectID | undefined | null =
+        item.projectId || item.project?.id;
+
+      const overrideUserId: ObjectID | undefined | null =
+        item.overrideUserId || item.overrideUser?.id;
+
+      const routeAlertsToUserId: ObjectID | undefined | null =
+        item.routeAlertsToUserId || item.routeAlertsToUser?.id;
+
+      if (
+        onCallDutyPolicyId &&
+        projectId &&
+        overrideUserId &&
+        routeAlertsToUserId
+      ) {
+        const onCallPolicyName: string | null =
+          await OnCallDutyPolicyService.getOnCallDutyPolicyName({
+            onCallDutyPolicyId: onCallDutyPolicyId,
+          });
+
+        const overrideUserTimezone: Timezone | null =
+          await UserService.getTimezoneForUser(overrideUserId);
+
+        const routeAlertsToUserTimezone: Timezone | null =
+          await UserService.getTimezoneForUser(routeAlertsToUserId);
+
+        const timezones: Timezone[] = [];
+        if (overrideUserTimezone) {
+          timezones.push(overrideUserTimezone);
+        }
+
+        if (routeAlertsToUserTimezone) {
+          timezones.push(routeAlertsToUserTimezone);
+        }
+
+        const deleteByUserId: ObjectID | undefined | null =
+          deleteBy.props.userId;
+
+        await OnCallDutyPolicyFeedService.createOnCallDutyPolicyFeedItem({
+          onCallDutyPolicyId: onCallDutyPolicyId,
+          projectId: projectId!,
+          onCallDutyPolicyFeedEventType:
+            OnCallDutyPolicyFeedEventType.UserOverrideRemoved,
+          displayColor: Gray500,
+          feedInfoInMarkdown: `❌ Removed a User Override Rule for user **${await UserService.getUserMarkdownString(
+            {
+              userId: overrideUserId,
+              projectId: projectId!,
+            },
+          )}** for the [On-Call Policy ${onCallPolicyName}](${(await OnCallDutyPolicyService.getOnCallDutyPolicyLinkInDashboard(projectId!, onCallDutyPolicyId!)).toString()}). All alerts will be routed back to **${await UserService.getUserMarkdownString(
+            {
+              userId: overrideUserId,
+              projectId: projectId!,
+            },
+          )}**`,
+          userId: deleteByUserId || undefined,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: deleteByUserId || undefined,
+          },
+        });
+      }
+    }
+
+    return {
+      deleteBy,
+      carryForward: null,
+    };
+  }
+
   @CaptureSpan()
   public async getOnCallDutyPolicyUserOverrideLinkInDashboard(data: {
     projectId: ObjectID;

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -40,6 +40,8 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import Monitor from "../../Models/DatabaseModels/Monitor";
 import Text from "../../Types/Text";
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
+import OnCallDutyPolicy from "../../Models/DatabaseModels/OnCallDutyPolicy";
 
 export interface MessageBlocksByWorkspaceType {
   workspaceType: WorkspaceType;
@@ -51,6 +53,7 @@ export interface NotificationFor {
   alertId?: ObjectID | undefined;
   scheduledMaintenanceId?: ObjectID | undefined;
   monitorId?: ObjectID | undefined;
+  onCallDutyPolicyId?: ObjectID | undefined;
 }
 
 export class Service extends DatabaseService<WorkspaceNotificationRule> {
@@ -438,6 +441,14 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
       });
     }
 
+    if (data.notificationFor.onCallDutyPolicyId) {
+      monitorChannels =
+        await OnCallDutyPolicyService.getWorkspaceChannelForOnCallDutyPolicy({
+          onCallDutyPolicyId: data.notificationFor.onCallDutyPolicyId,
+          workspaceType: data.workspaceType,
+        });
+    }
+
     // incidents
     if (data.notificationFor.incidentId) {
       monitorChannels = await IncidentService.getWorkspaceChannelForIncident({
@@ -482,6 +493,10 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
       return NotificationRuleEventType.Monitor;
     }
 
+    if (notificationFor.onCallDutyPolicyId) {
+      return NotificationRuleEventType.OnCallDutyPolicy;
+    }
+
     if (notificationFor.scheduledMaintenanceId) {
       return NotificationRuleEventType.ScheduledMaintenance;
     }
@@ -1451,6 +1466,11 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
           incident.monitors?.map((monitor: Incident) => {
             return monitor._id?.toString() || "";
           }) || [],
+
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyName]: undefined,
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyDescription]:
+          undefined,
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels]: undefined,
       };
     }
 
@@ -1523,6 +1543,11 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
         [NotificationRuleConditionCheckOn.Monitors]: [
           alert.monitor?.id!.toString() || "",
         ],
+
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyName]: undefined,
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyDescription]:
+          undefined,
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels]: undefined,
       };
     }
 
@@ -1602,6 +1627,10 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
               return monitor._id?.toString() || "";
             },
           ) || [],
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyName]: undefined,
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyDescription]:
+          undefined,
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels]: undefined,
       };
     }
 
@@ -1659,6 +1688,70 @@ export class Service extends DatabaseService<WorkspaceNotificationRule> {
         [NotificationRuleConditionCheckOn.Monitors]: [
           monitor?._id?.toString() || "",
         ],
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyName]: undefined,
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyDescription]:
+          undefined,
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels]: undefined,
+      };
+    }
+
+    if (data.notificationFor.onCallDutyPolicyId) {
+      logger.debug("Fetching on call policy details for ID:");
+      logger.debug(data.notificationFor.onCallDutyPolicyId);
+
+      const onCallDutyPolicy: OnCallDutyPolicy | null =
+        await OnCallDutyPolicyService.findOneById({
+          id: data.notificationFor.onCallDutyPolicyId,
+          select: {
+            name: true,
+            labels: true,
+            description: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (!onCallDutyPolicy) {
+        logger.debug("On Call Duty Policy not found for ID:");
+        logger.debug(data.notificationFor.onCallDutyPolicyId);
+        throw new BadDataException("On Call Duty Policy ID not found");
+      }
+
+      const onCallDutyPolicyLabels: Array<Label> =
+        onCallDutyPolicy?.labels || [];
+
+      return {
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyName]:
+          onCallDutyPolicy?.name || "",
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyDescription]:
+          onCallDutyPolicy?.description || "",
+        [NotificationRuleConditionCheckOn.OnCallDutyPolicyLabels]:
+          onCallDutyPolicyLabels.map((label: Label) => {
+            return label._id?.toString() || "";
+          }) || [],
+
+        [NotificationRuleConditionCheckOn.MonitorName]: undefined,
+        [NotificationRuleConditionCheckOn.IncidentTitle]: undefined,
+        [NotificationRuleConditionCheckOn.IncidentDescription]: undefined,
+        [NotificationRuleConditionCheckOn.IncidentSeverity]: undefined,
+        [NotificationRuleConditionCheckOn.IncidentState]: undefined,
+        [NotificationRuleConditionCheckOn.MonitorType]: undefined,
+        [NotificationRuleConditionCheckOn.MonitorStatus]: "",
+        [NotificationRuleConditionCheckOn.AlertTitle]: undefined,
+        [NotificationRuleConditionCheckOn.AlertDescription]: undefined,
+        [NotificationRuleConditionCheckOn.AlertSeverity]: undefined,
+        [NotificationRuleConditionCheckOn.AlertState]: undefined,
+        [NotificationRuleConditionCheckOn.ScheduledMaintenanceTitle]: undefined,
+        [NotificationRuleConditionCheckOn.ScheduledMaintenanceDescription]:
+          undefined,
+        [NotificationRuleConditionCheckOn.ScheduledMaintenanceState]: undefined,
+        [NotificationRuleConditionCheckOn.IncidentLabels]: undefined,
+        [NotificationRuleConditionCheckOn.AlertLabels]: undefined,
+        [NotificationRuleConditionCheckOn.MonitorLabels]: undefined,
+        [NotificationRuleConditionCheckOn.ScheduledMaintenanceLabels]:
+          undefined,
+        [NotificationRuleConditionCheckOn.Monitors]: undefined,
       };
     }
 

package/Server/Utils/StartServer.ts

@@ -1,7 +1,7 @@
 // Connect common api's.
 import CommonAPI from "../API/Index";
 import { StatusAPIOptions } from "../API/StatusAPI";
-import { AppVersion } from "../EnvironmentConfig";
+import { AppVersion, IsBillingEnabled } from "../EnvironmentConfig";
 import LocalCache from "../Infrastructure/LocalCache";
 import "./Environment";
 import Express, {
@@ -31,6 +31,7 @@ import Typeof from "Common/Types/Typeof";
 import CookieParser from "cookie-parser";
 import cors from "cors";
 import zlib from "zlib";
+import "ejs";
 // Make sure we have stack trace for debugging.
 Error.stackTraceLimit = Infinity;
 
@@ -200,7 +201,9 @@ const init: InitFunction = async (
     );
 
     app.get("/*", (_req: ExpressRequest, res: ExpressResponse) => {
-      res.sendFile("/usr/src/app/public/index.html");
+      return res.render("/usr/src/app/public/index.ejs", {
+        enableGoogleTagManager: IsBillingEnabled || false,
+      });
     });
   }
 

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

@@ -36,6 +36,9 @@ enum SlackActionType {
 
   // Monitor Actions
   ViewMonitor = "ViewMonitor",
+
+  // View on call policy.
+  ViewOnCallPolicy = "ViewOnCallPolicy",
 }
 
 export default SlackActionType;

package/Server/Utils/Workspace/Slack/Actions/OnCallDutyPolicy.ts

@@ -0,0 +1,48 @@
+import BadDataException from "../../../../../Types/Exception/BadDataException";
+import { ExpressRequest, ExpressResponse } from "../../../Express";
+import SlackActionType from "./ActionTypes";
+import { SlackAction, SlackRequest } from "./Auth";
+import Response from "../../../Response";
+import CaptureSpan from "../../../Telemetry/CaptureSpan";
+
+export default class SlackOnCallDutyActions {
+  @CaptureSpan()
+  public static isOnCallDutyAction(data: {
+    actionType: SlackActionType;
+  }): boolean {
+    const { actionType } = data;
+
+    switch (actionType) {
+      case SlackActionType.ViewOnCallPolicy:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  @CaptureSpan()
+  public static async handleOnCallDutyAction(data: {
+    slackRequest: SlackRequest;
+    action: SlackAction;
+    req: ExpressRequest;
+    res: ExpressResponse;
+  }): Promise<void> {
+    // now we should be all set, project is authorized and user is authorized. Lets perform some actions based on the action type.
+    const actionType: SlackActionType | undefined = data.action.actionType;
+
+    if (actionType === SlackActionType.ViewOnCallPolicy) {
+      // do nothing. This is just a view alert action.
+      // clear response.
+      return Response.sendJsonObjectResponse(data.req, data.res, {
+        response_action: "clear",
+      });
+    }
+
+    // invalid action type.
+    return Response.sendErrorResponse(
+      data.req,
+      data.res,
+      new BadDataException("Invalid Action Type"),
+    );
+  }
+}