@oneuptime/common 7.0.3707 → 7.0.3708

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -29,8 +29,12 @@ import WorkspaceUserAuthTokenService from "./WorkspaceUserAuthTokenService";
 import WorkspaceMessagePayload, {
   WorkspaceMessageBlock,
 } from "../../Types/Workspace/WorkspaceMessagePayload";
-import WorkspaceProjectAuthToken from "../../Models/DatabaseModels/WorkspaceProjectAuthToken";
+import WorkspaceProjectAuthToken, {
+  MiscData,
+  SlackMiscData,
+} from "../../Models/DatabaseModels/WorkspaceProjectAuthToken";
 import WorkspaceProjectAuthTokenService from "./WorkspaceProjectAuthTokenService";
+import logger from "../Utils/Logger";
 
 export interface NotificationFor {
   incidentId?: ObjectID | undefined;
@@ -44,6 +48,31 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  public getBotUserIdFromprojectAuthToken(data: {
+    projectAuthToken: WorkspaceProjectAuthToken;
+    workspaceType: WorkspaceType;
+  }): string {
+    const miscData: MiscData | undefined = data.projectAuthToken.miscData;
+
+    if (!miscData) {
+      throw new BadDataException("Misc data not found in project auth token");
+    }
+
+    if (data.workspaceType === WorkspaceType.Slack) {
+      const userId: string = (miscData as SlackMiscData).botUserId;
+
+      if (!userId) {
+        throw new BadDataException(
+          "Bot user ID not found in project auth token",
+        );
+      }
+
+      return userId;
+    }
+
+    throw new BadDataException("Workspace type not supported");
+  }
+
   public async createInviteAndPostToChannelsBasedOnRules(data: {
     projectId: ObjectID;
     notificationRuleEventType: NotificationRuleEventType;
@@ -53,6 +82,11 @@ export class Service extends DatabaseService<Model> {
   }): Promise<{
     channelsCreated: Array<WorkspaceChannel>;
   } | null> {
+    logger.debug(
+      "WorkspaceNotificationRuleService.createInviteAndPostToChannelsBasedOnRules",
+    );
+    logger.debug(data);
+
     const channelsCreated: Array<WorkspaceChannel> = [];
 
     const projectAuths: Array<WorkspaceProjectAuthToken> =
@@ -60,6 +94,9 @@ export class Service extends DatabaseService<Model> {
         projectId: data.projectId,
       });
 
+    logger.debug("projectAuths");
+    logger.debug(projectAuths);
+
     if (!projectAuths || projectAuths.length === 0) {
       // do nothing.
       return null;
@@ -85,10 +122,14 @@ export class Service extends DatabaseService<Model> {
           notificationFor: data.notificationFor,
         });
 
+      logger.debug("notificationRules");
+      logger.debug(notificationRules);
+
       if (!notificationRules || notificationRules.length === 0) {
         return null;
       }
 
+      logger.debug("Creating channels based on rules");
       const createdWorkspaceChannels: Array<WorkspaceChannel> =
         await this.createChannelsBasedOnRules({
           projectOrUserAuthTokenForWorkspasce: authToken,
@@ -100,6 +141,10 @@ export class Service extends DatabaseService<Model> {
           notificationEventType: data.notificationRuleEventType,
         });
 
+      logger.debug("createdWorkspaceChannels");
+      logger.debug(createdWorkspaceChannels);
+
+      logger.debug("Inviting users and teams to channels based on rules");
       await this.inviteUsersAndTeamsToChannelsBasedOnRules({
         projectId: data.projectId,
         projectOrUserAuthTokenForWorkspasce: authToken,
@@ -114,6 +159,7 @@ export class Service extends DatabaseService<Model> {
         ),
       });
 
+      logger.debug("Getting existing channel names from notification rules");
       const existingChannelNames: Array<string> =
         this.getExistingChannelNamesFromNotificationRules({
           notificationRules: notificationRules.map((rule: Model) => {
@@ -121,14 +167,25 @@ export class Service extends DatabaseService<Model> {
           }),
         }) || [];
 
-      // add created channel names to existing channel names.
+      logger.debug("Existing channel names:");
+      logger.debug(existingChannelNames);
+
+      logger.debug("Adding created channel names to existing channel names");
       for (const channel of createdWorkspaceChannels) {
         if (!existingChannelNames.includes(channel.name)) {
           existingChannelNames.push(channel.name);
         }
       }
 
+      logger.debug("Final list of channel names to post messages to:");
+      logger.debug(existingChannelNames);
+
+      logger.debug("Posting messages to workspace channels");
       await this.postToWorkspaceChannels({
+        workspaceUserId: this.getBotUserIdFromprojectAuthToken({
+          projectAuthToken: projectAuth,
+          workspaceType: workspaceType,
+        }),
         projectOrUserAuthTokenForWorkspasce: authToken,
         workspaceType: workspaceType,
         workspaceMessagePayload: {
@@ -138,23 +195,34 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
+      logger.debug("Channels created:");
+      logger.debug(createdWorkspaceChannels);
+
       channelsCreated.push(...createdWorkspaceChannels);
     }
 
+    logger.debug("Returning created channels");
     return {
       channelsCreated: channelsCreated,
     };
   }
 
   public async postToWorkspaceChannels(data: {
+    workspaceUserId: string;
     projectOrUserAuthTokenForWorkspasce: string;
     workspaceType: WorkspaceType;
     workspaceMessagePayload: WorkspaceMessagePayload;
   }): Promise<void> {
+    logger.debug("postToWorkspaceChannels called with data:");
+    logger.debug(data);
+
     await WorkspaceUtil.getWorkspaceTypeUtil(data.workspaceType).sendMessage({
+      userId: data.workspaceUserId,
       workspaceMessagePayload: data.workspaceMessagePayload,
       authToken: data.projectOrUserAuthTokenForWorkspasce,
     });
+
+    logger.debug("Message posted to workspace channels successfully");
   }
 
   public async inviteUsersAndTeamsToChannelsBasedOnRules(data: {
@@ -164,11 +232,17 @@ export class Service extends DatabaseService<Model> {
     notificationRules: Array<CreateChannelNotificationRule>;
     channelNames: Array<string>;
   }): Promise<void> {
+    logger.debug("inviteUsersAndTeamsToChannelsBasedOnRules called with data:");
+    logger.debug(data);
+
     const inviteUserIds: Array<ObjectID> =
       await this.getUsersIdsToInviteToChannel({
         notificationRules: data.notificationRules,
       });
 
+    logger.debug("User IDs to invite:");
+    logger.debug(inviteUserIds);
+
     const workspaceUserIds: Array<string> = [];
 
     for (const userId of inviteUserIds) {
@@ -176,7 +250,7 @@ export class Service extends DatabaseService<Model> {
         await this.getWorkspaceUserIdFromOneUptimeUserId({
           projectId: data.projectId,
           workspaceType: data.workspaceType,
-          oneupitmeUserId: userId,
+          oneuptimeUserId: userId,
         });
 
       if (workspaceUserId) {
@@ -184,6 +258,9 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    logger.debug("Workspace User IDs to invite:");
+    logger.debug(workspaceUserIds);
+
     await WorkspaceUtil.getWorkspaceTypeUtil(
       data.workspaceType,
     ).inviteUsersToChannels({
@@ -193,19 +270,24 @@ export class Service extends DatabaseService<Model> {
         workspaceUserIds: workspaceUserIds,
       },
     });
+
+    logger.debug("Users invited to channels successfully");
   }
 
   public async getWorkspaceUserIdFromOneUptimeUserId(data: {
     projectId: ObjectID;
     workspaceType: WorkspaceType;
-    oneupitmeUserId: ObjectID;
+    oneuptimeUserId: ObjectID;
   }): Promise<string | null> {
+    logger.debug("getWorkspaceUserIdFromOneUptimeUserId called with data:");
+    logger.debug(data);
+
     const userAuth: WorkspaceUserAuthToken | null =
       await WorkspaceUserAuthTokenService.findOneBy({
         query: {
           projectId: data.projectId,
           workspaceType: data.workspaceType,
-          userId: data.oneupitmeUserId,
+          userId: data.oneuptimeUserId,
         },
         select: {
           workspaceUserId: true,
@@ -216,9 +298,13 @@ export class Service extends DatabaseService<Model> {
       });
 
     if (!userAuth) {
+      logger.debug("No userAuth found for given data");
       return null;
     }
 
+    logger.debug("Found userAuth:");
+    logger.debug(userAuth);
+
     return userAuth.workspaceUserId?.toString() || null;
   }
 
@@ -229,6 +315,9 @@ export class Service extends DatabaseService<Model> {
     channelNameSiffix: string;
     notificationEventType: NotificationRuleEventType;
   }): Promise<Array<WorkspaceChannel>> {
+    logger.debug("createChannelsBasedOnRules called with data:");
+    logger.debug(data);
+
     const createdWorkspaceChannels: Array<WorkspaceChannel> = [];
     const createdChannelNames: Array<string> = [];
 
@@ -239,17 +328,23 @@ export class Service extends DatabaseService<Model> {
         notificationEventType: data.notificationEventType,
       });
 
+    logger.debug("New channel names to be created:");
+    logger.debug(newChannelNames);
+
     if (!newChannelNames || newChannelNames.length === 0) {
+      logger.debug("No new channel names found. Returning empty array.");
       return [];
     }
 
     for (const newChannelName of newChannelNames) {
-      // if already created then skip it.
       if (createdChannelNames.includes(newChannelName)) {
+        logger.debug(
+          `Channel name ${newChannelName} already created. Skipping.`,
+        );
         continue;
       }
 
-      // create channel.
+      logger.debug(`Creating new channel with name: ${newChannelName}`);
       const channel: WorkspaceChannel =
         await WorkspaceUtil.getWorkspaceTypeUtil(
           data.workspaceType,
@@ -258,17 +353,25 @@ export class Service extends DatabaseService<Model> {
           channelName: newChannelName,
         });
 
-      createdChannelNames.push(channel.name);
+      logger.debug("Channel created:");
+      logger.debug(channel);
 
+      createdChannelNames.push(channel.name);
       createdWorkspaceChannels.push(channel);
     }
 
+    logger.debug("Returning created workspace channels:");
+    logger.debug(createdWorkspaceChannels);
+
     return createdWorkspaceChannels;
   }
 
   public async getUsersIdsToInviteToChannel(data: {
     notificationRules: Array<CreateChannelNotificationRule>;
   }): Promise<Array<ObjectID>> {
+    logger.debug("getUsersIdsToInviteToChannel called with data:");
+    logger.debug(data);
+
     const inviteUserIds: Array<ObjectID> = [];
 
     for (const notificationRule of data.notificationRules) {
@@ -282,6 +385,9 @@ export class Service extends DatabaseService<Model> {
           const userIds: Array<ObjectID> =
             workspaceRules.inviteUsersToNewChannel || [];
 
+          logger.debug("User IDs to invite from rule:");
+          logger.debug(userIds);
+
           for (const userId of userIds) {
             if (
               !inviteUserIds.find((id: ObjectID) => {
@@ -304,9 +410,15 @@ export class Service extends DatabaseService<Model> {
             return new ObjectID(teamId.toString());
           });
 
+          logger.debug("Team IDs to invite from rule:");
+          logger.debug(teamIds);
+
           const usersInTeam: Array<User> =
             await TeamMemberService.getUsersInTeams(teamIds);
 
+          logger.debug("Users in teams:");
+          logger.debug(usersInTeam);
+
           for (const user of usersInTeam) {
             if (
               !inviteUserIds.find((id: ObjectID) => {
@@ -323,12 +435,20 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
+    logger.debug("Final list of user IDs to invite:");
+    logger.debug(inviteUserIds);
+
     return inviteUserIds;
   }
 
   public getExistingChannelNamesFromNotificationRules(data: {
     notificationRules: Array<BaseNotificationRule>;
   }): Array<string> {
+    logger.debug(
+      "getExistingChannelNamesFromNotificationRules called with data:",
+    );
+    logger.debug(data);
+
     const channelNames: Array<string> = [];
 
     for (const notificationRule of data.notificationRules) {
@@ -338,20 +458,25 @@ export class Service extends DatabaseService<Model> {
         const existingChannelNames: Array<string> =
           workspaceRules.existingChannelNames.split(",");
 
+        logger.debug("Existing channel names from rule:");
+        logger.debug(existingChannelNames);
+
         for (const channelName of existingChannelNames) {
           if (!channelName) {
-            // if channel name is empty then skip it.
+            logger.debug("Empty channel name found. Skipping.");
             continue;
           }
 
           if (!channelNames.includes(channelName)) {
-            // if channel name is not already added then add it.
             channelNames.push(channelName);
           }
         }
       }
     }
 
+    logger.debug("Final list of existing channel names:");
+    logger.debug(channelNames);
+
     return channelNames;
   }
 
@@ -360,11 +485,17 @@ export class Service extends DatabaseService<Model> {
     notificationRules: Array<CreateChannelNotificationRule>;
     channelNameSiffix: string;
   }): Array<string> {
+    logger.debug("getNewChannelNamesFromNotificationRules called with data:");
+    logger.debug(data);
+
     const channelNames: Array<string> = [];
 
     for (const notificationRule of data.notificationRules) {
       const workspaceRules: CreateChannelNotificationRule = notificationRule;
 
+      logger.debug("Processing notification rule:");
+      logger.debug(workspaceRules);
+
       if (
         workspaceRules.shouldCreateNewChannel &&
         workspaceRules.newChannelTemplateName
@@ -373,16 +504,30 @@ export class Service extends DatabaseService<Model> {
           workspaceRules.newChannelTemplateName ||
           `oneuptime-${data.notificationEventType.toLowerCase()}-`;
 
+        logger.debug("New channel template name:");
+        logger.debug(newChannelName);
+
         // add suffix and then check if it is already added or not.
         const channelName: string = newChannelName + data.channelNameSiffix;
 
+        logger.debug("Final channel name with suffix:");
+        logger.debug(channelName);
+
         if (!channelNames.includes(channelName)) {
           // if channel name is not already added then add it.
           channelNames.push(channelName);
+          logger.debug(`Channel name ${channelName} added to the list.`);
+        } else {
+          logger.debug(
+            `Channel name ${channelName} already exists in the list. Skipping.`,
+          );
         }
       }
     }
 
+    logger.debug("Final list of new channel names:");
+    logger.debug(channelNames);
+
     return channelNames;
   }
 
@@ -391,7 +536,10 @@ export class Service extends DatabaseService<Model> {
     workspaceType: WorkspaceType;
     notificationRuleEventType: NotificationRuleEventType;
   }): Promise<Array<Model>> {
-    return await this.findBy({
+    logger.debug("getNotificationRules called with data:");
+    logger.debug(data);
+
+    const notificationRules: Array<Model> = await this.findBy({
       query: {
         projectId: data.projectId,
         workspaceType: data.workspaceType,
@@ -406,6 +554,11 @@ export class Service extends DatabaseService<Model> {
       skip: 0,
       limit: LIMIT_PER_PROJECT,
     });
+
+    logger.debug("Notification rules retrieved:");
+    logger.debug(notificationRules);
+
+    return notificationRules;
   }
 
   private async getValuesBasedOnNotificationFor(data: {
@@ -416,7 +569,13 @@ export class Service extends DatabaseService<Model> {
       | Array<string>
       | undefined;
   }> {
+    logger.debug("getValuesBasedOnNotificationFor called with data:");
+    logger.debug(data);
+
     if (data.notificationFor.incidentId) {
+      logger.debug("Fetching incident details for incident ID:");
+      logger.debug(data.notificationFor.incidentId);
+
       const incident: Incident | null = await IncidentService.findOneById({
         id: data.notificationFor.incidentId,
         select: {
@@ -433,9 +592,14 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (!incident) {
+        logger.debug("Incident not found for ID:");
+        logger.debug(data.notificationFor.incidentId);
         throw new BadDataException("Incident ID not found");
       }
 
+      logger.debug("Incident details retrieved:");
+      logger.debug(incident);
+
       const monitorLabels: Array<Label> =
         await MonitorService.getLabelsForMonitors({
           monitorIds:
@@ -444,6 +608,9 @@ export class Service extends DatabaseService<Model> {
             }) || [],
         });
 
+      logger.debug("Monitor labels retrieved:");
+      logger.debug(monitorLabels);
+
       return {
         [NotificationRuleConditionCheckOn.MonitorName]: undefined,
         [NotificationRuleConditionCheckOn.IncidentTitle]: incident.title || "",
@@ -482,6 +649,9 @@ export class Service extends DatabaseService<Model> {
     }
 
     if (data.notificationFor.alertId) {
+      logger.debug("Fetching alert details for alert ID:");
+      logger.debug(data.notificationFor.alertId);
+
       const alert: Alert | null = await AlertService.findOneById({
         id: data.notificationFor.alertId,
         select: {
@@ -498,14 +668,22 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (!alert) {
+        logger.debug("Alert not found for ID:");
+        logger.debug(data.notificationFor.alertId);
         throw new BadDataException("Alert ID not found");
       }
 
+      logger.debug("Alert details retrieved:");
+      logger.debug(alert);
+
       const monitorLabels: Array<Label> =
         await MonitorService.getLabelsForMonitors({
           monitorIds: alert?.monitor?.id ? [alert?.monitor?.id] : [],
         });
 
+      logger.debug("Monitor labels retrieved:");
+      logger.debug(monitorLabels);
+
       return {
         [NotificationRuleConditionCheckOn.MonitorName]: undefined,
         [NotificationRuleConditionCheckOn.IncidentTitle]: undefined,
@@ -543,6 +721,9 @@ export class Service extends DatabaseService<Model> {
     }
 
     if (data.notificationFor.scheduledMaintenanceId) {
+      logger.debug("Fetching scheduled maintenance details for ID:");
+      logger.debug(data.notificationFor.scheduledMaintenanceId);
+
       const scheduledMaintenance: ScheduledMaintenance | null =
         await ScheduledMaintenanceService.findOneById({
           id: data.notificationFor.scheduledMaintenanceId,
@@ -559,9 +740,14 @@ export class Service extends DatabaseService<Model> {
         });
 
       if (!scheduledMaintenance) {
+        logger.debug("Scheduled maintenance not found for ID:");
+        logger.debug(data.notificationFor.scheduledMaintenanceId);
         throw new BadDataException("Scheduled Maintenance ID not found");
       }
 
+      logger.debug("Scheduled maintenance details retrieved:");
+      logger.debug(scheduledMaintenance);
+
       const monitorLabels: Array<Label> =
         await MonitorService.getLabelsForMonitors({
           monitorIds:
@@ -572,6 +758,9 @@ export class Service extends DatabaseService<Model> {
             ) || [],
         });
 
+      logger.debug("Monitor labels retrieved:");
+      logger.debug(monitorLabels);
+
       return {
         [NotificationRuleConditionCheckOn.MonitorName]: undefined,
         [NotificationRuleConditionCheckOn.IncidentTitle]: undefined,
@@ -611,6 +800,9 @@ export class Service extends DatabaseService<Model> {
     }
 
     if (data.notificationFor.monitorStatusTimelineId) {
+      logger.debug("Fetching monitor status timeline details for ID:");
+      logger.debug(data.notificationFor.monitorStatusTimelineId);
+
       const monitorStatusTimeline: MonitorStatusTimeline | null =
         await MonitorStatusTimelineService.findOneById({
           id: data.notificationFor.monitorStatusTimelineId,
@@ -628,6 +820,8 @@ export class Service extends DatabaseService<Model> {
         });
 
       if (!monitorStatusTimeline) {
+        logger.debug("Monitor status timeline not found for ID:");
+        logger.debug(data.notificationFor.monitorStatusTimelineId);
         throw new BadDataException("Monitor Status Timeline ID not found");
       }
 

package/Server/Services/WorkspaceProjectAuthTokenService.ts

@@ -24,6 +24,7 @@ export class Service extends DatabaseService<Model> {
         authToken: true,
         workspaceProjectId: true,
         miscData: true,
+        workspaceType: true,
       },
       props: {
         isRoot: true,

package/Server/Types/Workflow/Components/BaseModel/OnTriggerBaseModel.ts

@@ -74,7 +74,15 @@ export default class OnTriggerBaseModel<
     args: JSONObject,
     options: RunOptions,
   ): Promise<RunReturnType> {
-    const data: JSONObject = args["data"] as JSONObject;
+    let data: JSONObject = args["data"] as JSONObject;
+
+    if (!data) {
+      data = {};
+    }
+
+    if (args["_id"]) {
+      data["_id"] = args["_id"];
+    }
 
     const miscData: JSONObject = (data?.["miscData"] as JSONObject) || {};
 
@@ -106,14 +114,15 @@ export default class OnTriggerBaseModel<
 
     let select: Select<TBaseModel> = args["select"] as Select<TBaseModel>;
 
-    if (select) {
-      select = JSONFunctions.deserialize(
-        args["select"] as JSONObject,
-      ) as Select<TBaseModel>;
+    logger.debug("Select: ");
+    logger.debug(select);
+
+    if (select && typeof select === "string") {
+      select = JSONFunctions.parse(select) as Select<TBaseModel>;
     }
 
     const model: TBaseModel | null = await this.service!.findOneById({
-      id: new ObjectID(data["_id"] as string),
+      id: new ObjectID(data["_id"].toString()),
       props: {
         isRoot: true,
       },
@@ -124,8 +133,10 @@ export default class OnTriggerBaseModel<
     });
 
     if (!model) {
+      options.log("Model not found with id " + data["_id"].toString());
+
       throw new BadDataException(
-        ("Model not found with id " + args["_id"]) as string,
+        ("Model not found with id " + data["_id"].toString()) as string,
       );
     }