@oneuptime/common 7.0.3718 → 7.0.3815

package/build/dist/Server/Services/WorkspaceNotificationRuleService.js

@@ -1,7 +1,6 @@
 import ObjectID from "../../Types/ObjectID";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 import DatabaseService from "./DatabaseService";
-import Model from "Common/Models/DatabaseModels/WorkspaceNotificationRule";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import IncidentService from "./IncidentService";
 import { NotificationRuleConditionCheckOn } from "../../Types/Workspace/NotificationRules/NotificationRuleCondition";
@@ -16,9 +15,14 @@ import WorkspaceUtil from "../Utils/Workspace/Workspace";
 import WorkspaceUserAuthTokenService from "./WorkspaceUserAuthTokenService";
 import WorkspaceProjectAuthTokenService from "./WorkspaceProjectAuthTokenService";
 import logger from "../Utils/Logger";
+import WorkspaceNotificationRule from "Common/Models/DatabaseModels/WorkspaceNotificationRule";
+import UserService from "./UserService";
 export class Service extends DatabaseService {
     constructor() {
-        super(Model);
+        super(WorkspaceNotificationRule);
+    }
+    static getAllWorkspaceTypes() {
+        return [WorkspaceType.Slack, WorkspaceType.MicrosoftTeams];
     }
     getBotUserIdFromprojectAuthToken(data) {
         const miscData = data.projectAuthToken.miscData;
@@ -34,7 +38,26 @@ export class Service extends DatabaseService {
         }
         throw new BadDataException("Workspace type not supported");
     }
-    async createInviteAndPostToChannelsBasedOnRules(data) {
+    async getExistingChannelNamesBasedOnEventType(data) {
+        logger.debug("getExistingChannelNamesBasedOnEventType called with data:");
+        logger.debug(data);
+        const notificationRules = await this.getNotificationRules({
+            projectId: data.projectId,
+            workspaceType: data.workspaceType,
+            notificationRuleEventType: data.notificationRuleEventType,
+        });
+        logger.debug("Notification rules retrieved:");
+        logger.debug(notificationRules);
+        const existingChannelNames = this.getExistingChannelNamesFromNotificationRules({
+            notificationRules: notificationRules.map((rule) => {
+                return rule.notificationRule;
+            }),
+        }) || [];
+        logger.debug("Existing channel names:");
+        logger.debug(existingChannelNames);
+        return existingChannelNames;
+    }
+    async createChannelsAndInviteUsersToChannelsBasedOnRules(data) {
         logger.debug("WorkspaceNotificationRuleService.createInviteAndPostToChannelsBasedOnRules");
         logger.debug(data);
         const channelsCreated = [];
@@ -69,11 +92,9 @@ export class Service extends DatabaseService {
             }
             logger.debug("Creating channels based on rules");
             const createdWorkspaceChannels = await this.createChannelsBasedOnRules({
-                projectOrUserAuthTokenForWorkspasce: authToken,
+                projectOrUserAuthTokenForWorkspace: authToken,
                 workspaceType: workspaceType,
-                notificationRules: notificationRules.map((rule) => {
-                    return rule.notificationRule;
-                }),
+                notificationRules: notificationRules,
                 channelNameSiffix: data.channelNameSiffix,
                 notificationEventType: data.notificationRuleEventType,
             });
@@ -82,14 +103,10 @@ export class Service extends DatabaseService {
             logger.debug("Inviting users and teams to channels based on rules");
             await this.inviteUsersAndTeamsToChannelsBasedOnRules({
                 projectId: data.projectId,
-                projectOrUserAuthTokenForWorkspasce: authToken,
+                projectAuth: projectAuth,
                 workspaceType: workspaceType,
-                notificationRules: notificationRules.map((rule) => {
-                    return rule.notificationRule;
-                }),
-                channelNames: createdWorkspaceChannels.map((channel) => {
-                    return channel.name;
-                }),
+                notificationRules: notificationRules,
+                notificationChannels: createdWorkspaceChannels,
             });
             logger.debug("Getting existing channel names from notification rules");
             const existingChannelNames = this.getExistingChannelNamesFromNotificationRules({
@@ -108,19 +125,6 @@ export class Service extends DatabaseService {
             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: {
-                    _type: "WorkspaceMessagePayload",
-                    channelNames: existingChannelNames,
-                    messageBlocks: data.messageBlocks,
-                },
-            });
             logger.debug("Channels created:");
             logger.debug(createdWorkspaceChannels);
             channelsCreated.push(...createdWorkspaceChannels);
@@ -130,45 +134,248 @@ export class Service extends DatabaseService {
             channelsCreated: channelsCreated,
         };
     }
-    async postToWorkspaceChannels(data) {
-        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");
+    async getNotificationRulesWhereOnCallIsTrue(data) {
+        const workspaceTypes = Service.getAllWorkspaceTypes();
+        const result = [];
+        for (const workspaceType of workspaceTypes) {
+            // get matching notification rules
+            const notificationRules = await this.getMatchingNotificationRules({
+                projectId: data.projectId,
+                notificationFor: data.notificationFor,
+                workspaceType: workspaceType,
+                notificationRuleEventType: data.notificationRuleEventType,
+            });
+            const filteredNotificationRules = notificationRules.filter((rule) => {
+                return rule.notificationRule
+                    .shouldAutomaticallyInviteOnCallUsersToNewChannel;
+            });
+            result.push(...filteredNotificationRules);
+        }
+        return result;
+    }
+    async getNotificationRulesWhereInviteOwnersIsTrue(data) {
+        const workspaceTypes = Service.getAllWorkspaceTypes();
+        const result = [];
+        for (const workspaceType of workspaceTypes) {
+            // get matching notification rules
+            const notificationRules = await this.getMatchingNotificationRules({
+                projectId: data.projectId,
+                notificationFor: data.notificationFor,
+                workspaceType: workspaceType,
+                notificationRuleEventType: data.notificationRuleEventType,
+            });
+            const filteredNotificationRules = notificationRules.filter((rule) => {
+                return rule.notificationRule
+                    .shouldInviteOwnersToNewChannel;
+            });
+            result.push(...filteredNotificationRules);
+        }
+        return result;
     }
     async inviteUsersAndTeamsToChannelsBasedOnRules(data) {
+        var _a, _b;
         logger.debug("inviteUsersAndTeamsToChannelsBasedOnRules called with data:");
         logger.debug(data);
-        const inviteUserIds = await this.getUsersIdsToInviteToChannel({
+        const inviteUserPayloads = await this.getUsersIdsToInviteToChannel({
             notificationRules: data.notificationRules,
         });
-        logger.debug("User IDs to invite:");
-        logger.debug(inviteUserIds);
-        const workspaceUserIds = [];
-        for (const userId of inviteUserIds) {
-            const workspaceUserId = await this.getWorkspaceUserIdFromOneUptimeUserId({
-                projectId: data.projectId,
-                workspaceType: data.workspaceType,
-                oneuptimeUserId: userId,
+        logger.debug("User IDs to invite by Workspace Notification Rule ID:");
+        logger.debug(inviteUserPayloads);
+        for (const inviteUserPayload of inviteUserPayloads) {
+            const userIds = inviteUserPayload.userIds;
+            const workspaceUserIds = [];
+            for (const userId of userIds) {
+                const workspaceUserId = await this.getWorkspaceUserIdFromOneUptimeUserId({
+                    projectId: data.projectId,
+                    workspaceType: data.workspaceType,
+                    oneuptimeUserId: userId,
+                });
+                if (workspaceUserId) {
+                    workspaceUserIds.push(workspaceUserId);
+                }
+                else {
+                    try {
+                        // send a message to channel that user cannot be invited because the account is not connected to workspace.
+                        const channelIds = ((_b = (_a = data.notificationChannels) === null || _a === void 0 ? void 0 : _a.filter((channel) => {
+                            return (channel.notificationRuleId ===
+                                inviteUserPayload.notificationRuleId);
+                        })) === null || _b === void 0 ? void 0 : _b.map((channel) => {
+                            return channel.id;
+                        })) || [];
+                        logger.debug("Channel IDs to send message to:");
+                        logger.debug(channelIds);
+                        await WorkspaceUtil.getWorkspaceTypeUtil(data.workspaceType).sendMessage({
+                            userId: data.projectAuth.workspaceProjectId,
+                            authToken: data.projectAuth.authToken,
+                            workspaceMessagePayload: {
+                                _type: "WorkspaceMessagePayload",
+                                channelNames: [],
+                                channelIds: channelIds,
+                                workspaceType: data.workspaceType,
+                                messageBlocks: [
+                                    {
+                                        _type: "WorkspacePayloadMarkdown",
+                                        text: `${await UserService.getUserMarkdownString({
+                                            userId: userId,
+                                            projectId: data.projectId,
+                                        })} cannot be invited to the channel because the account is not connected to ${data.workspaceType}. Please go to User Settings > ${data.workspaceType} on OneUptime Dashboard and connect the account.`,
+                                    },
+                                ],
+                            },
+                        });
+                    }
+                    catch (e) {
+                        logger.error("Error in sending message to channel");
+                        logger.error(e);
+                    }
+                }
+                logger.debug("Workspace User IDs to invite:");
+                logger.debug(workspaceUserIds);
+                await WorkspaceUtil.getWorkspaceTypeUtil(data.workspaceType).inviteUsersToChannels({
+                    authToken: data.projectAuth.authToken,
+                    workspaceChannelInvitationPayload: {
+                        channelNames: data.notificationChannels
+                            .filter((channel) => {
+                            return (channel.notificationRuleId ===
+                                inviteUserPayload.notificationRuleId);
+                        })
+                            .map((channel) => {
+                            return channel.name;
+                        }),
+                        workspaceUserIds: workspaceUserIds,
+                    },
+                });
+            }
+        }
+        logger.debug("Users invited to channels successfully");
+    }
+    async inviteUsersBasedOnRulesAndWorkspaceChannels(data) {
+        // if no rules then return.
+        if (data.notificationRules.length === 0) {
+            logger.debug("No notification rules found. Returning.");
+            return;
+        }
+        logger.debug("inviteUsersBasedOnRulesAndWorkspaceChannels called with data:");
+        logger.debug(data);
+        const userIds = data.userIds;
+        logger.debug("Users:");
+        logger.debug(userIds);
+        // get all Workspaces.
+        const workspaceTypes = Service.getAllWorkspaceTypes();
+        for (const workspaceType of workspaceTypes) {
+            // filter rules by workspaceType.
+            const notificationRules = data.notificationRules.filter((rule) => {
+                return rule.workspaceType === workspaceType;
+            });
+            logger.debug("Notification rules for workspace type:");
+            logger.debug(notificationRules);
+            const channelsToInviteToBasedOnRule = data.workspaceChannels.filter((channel) => {
+                return notificationRules.find((rule) => {
+                    var _a;
+                    return ((_a = rule.id) === null || _a === void 0 ? void 0 : _a.toString()) === channel.notificationRuleId;
+                });
+            });
+            logger.debug("Channels to invite to based on rule:");
+            logger.debug(channelsToInviteToBasedOnRule);
+            if (channelsToInviteToBasedOnRule.length === 0) {
+                logger.debug("No channels to invite to based on rule.");
+                continue;
+            }
+            // get auth token for workspace.
+            const projectAuth = await WorkspaceProjectAuthTokenService.findOneBy({
+                query: {
+                    projectId: data.projectId,
+                    workspaceType: workspaceType,
+                },
+                select: {
+                    authToken: true,
+                },
+                props: {
+                    isRoot: true,
+                },
             });
-            if (workspaceUserId) {
-                workspaceUserIds.push(workspaceUserId);
+            if (!projectAuth) {
+                logger.debug("No project auth found for workspace type");
+                continue;
+            }
+            // inivte users to channels.
+            const workspaceUserIds = [];
+            for (const userId of userIds) {
+                const workspaceUserId = await this.getWorkspaceUserIdFromOneUptimeUserId({
+                    projectId: data.projectId,
+                    workspaceType: workspaceType,
+                    oneuptimeUserId: userId,
+                });
+                if (workspaceUserId) {
+                    workspaceUserIds.push(workspaceUserId);
+                }
+                else {
+                    try {
+                        // send a message to channel that user cannot be invited because the account is not connected to workspace.
+                        const channelIds = channelsToInviteToBasedOnRule.map((channel) => {
+                            return channel.id;
+                        });
+                        logger.debug("Channel IDs to send message to:");
+                        logger.debug(channelIds);
+                        await WorkspaceUtil.getWorkspaceTypeUtil(workspaceType).sendMessage({
+                            userId: projectAuth.workspaceProjectId,
+                            authToken: projectAuth.authToken,
+                            workspaceMessagePayload: {
+                                _type: "WorkspaceMessagePayload",
+                                channelNames: [],
+                                channelIds: channelIds,
+                                workspaceType: workspaceType,
+                                messageBlocks: [
+                                    {
+                                        _type: "WorkspacePayloadMarkdown",
+                                        text: `${await UserService.getUserMarkdownString({
+                                            userId: userId,
+                                            projectId: data.projectId,
+                                        })} cannot be invited to the channel because the account is not connected to ${workspaceType}. Please go to User Settings > ${workspaceType} on OneUptime Dashboard and connect the account.`,
+                                    },
+                                ],
+                            },
+                        });
+                    }
+                    catch (e) {
+                        logger.error("Error in sending message to channel");
+                        logger.error(e);
+                    }
+                }
             }
+            logger.debug("Workspace User IDs to invite:");
+            logger.debug(workspaceUserIds);
+            const channelNames = channelsToInviteToBasedOnRule.map((channel) => {
+                return channel.name;
+            });
+            logger.debug("Channel names to invite to:");
+            logger.debug(channelNames);
+            await WorkspaceUtil.getWorkspaceTypeUtil(workspaceType).inviteUsersToChannels({
+                authToken: projectAuth.authToken,
+                workspaceChannelInvitationPayload: {
+                    channelNames: channelNames,
+                    workspaceUserIds: workspaceUserIds,
+                },
+            });
         }
-        logger.debug("Workspace User IDs to invite:");
-        logger.debug(workspaceUserIds);
-        await WorkspaceUtil.getWorkspaceTypeUtil(data.workspaceType).inviteUsersToChannels({
-            authToken: data.projectOrUserAuthTokenForWorkspasce,
-            workspaceChannelInvitationPayload: {
-                channelNames: data.channelNames,
-                workspaceUserIds: workspaceUserIds,
-            },
+    }
+    async inviteTeamsBasedOnRulesAndWorkspaceChannels(data) {
+        // if no rules then return.
+        if (data.notificationRules.length === 0) {
+            logger.debug("No notification rules found. Returning.");
+            return;
+        }
+        const usersInTeam = await TeamMemberService.getUsersInTeams(data.teamIds);
+        logger.debug("Users in teams:");
+        logger.debug(usersInTeam);
+        return this.inviteUsersBasedOnRulesAndWorkspaceChannels({
+            workspaceChannels: data.workspaceChannels,
+            projectId: data.projectId,
+            notificationRules: data.notificationRules,
+            userIds: usersInTeam.map((user) => {
+                return user.id;
+            }),
         });
-        logger.debug("Users invited to channels successfully");
     }
     async getWorkspaceUserIdFromOneUptimeUserId(data) {
         var _a;
@@ -200,31 +407,34 @@ export class Service extends DatabaseService {
         logger.debug(data);
         const createdWorkspaceChannels = [];
         const createdChannelNames = [];
-        const newChannelNames = this.getNewChannelNamesFromNotificationRules({
+        const notificationChannels = this.getnotificationChannelssFromNotificationRules({
             notificationRules: data.notificationRules,
             channelNameSiffix: data.channelNameSiffix,
             notificationEventType: data.notificationEventType,
         });
         logger.debug("New channel names to be created:");
-        logger.debug(newChannelNames);
-        if (!newChannelNames || newChannelNames.length === 0) {
+        logger.debug(notificationChannels);
+        if (!notificationChannels || notificationChannels.length === 0) {
             logger.debug("No new channel names found. Returning empty array.");
             return [];
         }
-        for (const newChannelName of newChannelNames) {
-            if (createdChannelNames.includes(newChannelName)) {
-                logger.debug(`Channel name ${newChannelName} already created. Skipping.`);
+        for (const notificationChannel of notificationChannels) {
+            if (createdChannelNames.filter((name) => {
+                return name === notificationChannel.channelName;
+            }).length > 0) {
+                logger.debug(`Channel name ${notificationChannel.channelName} already created. Skipping.`);
                 continue;
             }
-            logger.debug(`Creating new channel with name: ${newChannelName}`);
+            logger.debug(`Creating new channel with name: ${notificationChannel.channelName}`);
             const channel = await WorkspaceUtil.getWorkspaceTypeUtil(data.workspaceType).createChannel({
-                authToken: data.projectOrUserAuthTokenForWorkspasce,
-                channelName: newChannelName,
+                authToken: data.projectOrUserAuthTokenForWorkspace,
+                channelName: notificationChannel.channelName,
             });
+            const notificationWorkspaceChannel = Object.assign(Object.assign({}, channel), { notificationRuleId: notificationChannel.notificationRuleId });
             logger.debug("Channel created:");
             logger.debug(channel);
             createdChannelNames.push(channel.name);
-            createdWorkspaceChannels.push(channel);
+            createdWorkspaceChannels.push(notificationWorkspaceChannel);
         }
         logger.debug("Returning created workspace channels:");
         logger.debug(createdWorkspaceChannels);
@@ -234,9 +444,10 @@ export class Service extends DatabaseService {
         var _a;
         logger.debug("getUsersIdsToInviteToChannel called with data:");
         logger.debug(data);
-        const inviteUserIds = [];
-        for (const notificationRule of data.notificationRules) {
-            const workspaceRules = notificationRule;
+        const result = [];
+        for (const workspaceNotificationRule of data.notificationRules) {
+            const inviteUserIds = [];
+            const workspaceRules = workspaceNotificationRule.notificationRule;
             if (workspaceRules.shouldCreateNewChannel) {
                 if (workspaceRules.inviteUsersToNewChannel &&
                     workspaceRules.inviteUsersToNewChannel.length > 0) {
@@ -275,10 +486,16 @@ export class Service extends DatabaseService {
                     }
                 }
             }
+            if (inviteUserIds.length > 0) {
+                result.push({
+                    notificationRuleId: workspaceNotificationRule.id.toString(),
+                    userIds: inviteUserIds,
+                });
+            }
         }
         logger.debug("Final list of user IDs to invite:");
-        logger.debug(inviteUserIds);
-        return inviteUserIds;
+        logger.debug(result);
+        return result;
     }
     getExistingChannelNamesFromNotificationRules(data) {
         logger.debug("getExistingChannelNamesFromNotificationRules called with data:");
@@ -305,27 +522,31 @@ export class Service extends DatabaseService {
         logger.debug(channelNames);
         return channelNames;
     }
-    getNewChannelNamesFromNotificationRules(data) {
-        logger.debug("getNewChannelNamesFromNotificationRules called with data:");
+    getnotificationChannelssFromNotificationRules(data) {
+        logger.debug("getnotificationChannelssFromNotificationRules called with data:");
         logger.debug(data);
-        const channelNames = [];
+        const channels = [];
         for (const notificationRule of data.notificationRules) {
-            const workspaceRules = notificationRule;
+            const workspaceRules = notificationRule.notificationRule;
             logger.debug("Processing notification rule:");
             logger.debug(workspaceRules);
-            if (workspaceRules.shouldCreateNewChannel &&
-                workspaceRules.newChannelTemplateName) {
-                const newChannelName = workspaceRules.newChannelTemplateName ||
+            if (workspaceRules.shouldCreateNewChannel) {
+                const notificationChannels = workspaceRules.newChannelTemplateName ||
                     `oneuptime-${data.notificationEventType.toLowerCase()}-`;
                 logger.debug("New channel template name:");
-                logger.debug(newChannelName);
+                logger.debug(notificationChannels);
                 // add suffix and then check if it is already added or not.
-                const channelName = newChannelName + data.channelNameSiffix;
+                const channelName = notificationChannels + data.channelNameSiffix;
                 logger.debug("Final channel name with suffix:");
                 logger.debug(channelName);
-                if (!channelNames.includes(channelName)) {
+                if (channels.filter((name) => {
+                    return name.channelName === channelName;
+                }).length === 0) {
                     // if channel name is not already added then add it.
-                    channelNames.push(channelName);
+                    channels.push({
+                        channelName: channelName,
+                        notificationRuleId: notificationRule.id.toString() || "",
+                    });
                     logger.debug(`Channel name ${channelName} added to the list.`);
                 }
                 else {
@@ -334,8 +555,8 @@ export class Service extends DatabaseService {
             }
         }
         logger.debug("Final list of new channel names:");
-        logger.debug(channelNames);
-        return channelNames;
+        logger.debug(channels);
+        return channels;
     }
     async getNotificationRules(data) {
         logger.debug("getNotificationRules called with data:");
@@ -348,6 +569,8 @@ export class Service extends DatabaseService {
             },
             select: {
                 notificationRule: true,
+                workspaceType: true,
+                eventType: true,
             },
             props: {
                 isRoot: true,
@@ -604,17 +827,26 @@ export class Service extends DatabaseService {
             workspaceType: data.workspaceType,
             notificationRuleEventType: data.notificationRuleEventType,
         });
+        logger.debug("Notification rules retrieved:");
+        logger.debug(notificationRules);
         const values = await this.getValuesBasedOnNotificationFor({
             notificationFor: data.notificationFor,
         });
+        logger.debug("Values based on notification for:");
+        logger.debug(values);
         const matchingNotificationRules = [];
         for (const notificationRule of notificationRules) {
+            logger.debug("Checking if rule matches:");
             if (WorkspaceNotificationRuleUtil.isRuleMatching({
                 notificationRule: notificationRule.notificationRule,
                 values: values,
             })) {
+                logger.debug("Rule matches. Adding to the list.");
                 matchingNotificationRules.push(notificationRule);
             }
+            else {
+                logger.debug("Rule does not match. Skipping.");
+            }
         }
         return matchingNotificationRules;
     }