@oneuptime/common 7.0.3786 → 7.0.3815

package/Server/API/SlackAPI.ts

@@ -30,6 +30,9 @@ import SlackAuthAction, {
   SlackRequest,
 } from "../Utils/Workspace/Slack/Actions/Auth";
 import SlackIncidentActions from "../Utils/Workspace/Slack/Actions/Incident";
+import SlackAlertActions from "../Utils/Workspace/Slack/Actions/Alert";
+import SlackScheduledMaintenanceActions from "../Utils/Workspace/Slack/Actions/ScheduledMaintenance";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
 
 export default class SlackAPI {
   public getRouter(): ExpressRouter {
@@ -283,6 +286,43 @@ export default class SlackAPI {
         logger.debug("Slack Interactive Auth Result: ");
         logger.debug(authResult);
 
+        // if slack uninstall app then,
+        if (authResult.payloadType === "app_uninstall") {
+          logger.debug("Slack App Uninstall Request: ");
+
+          // remove the project auth and user auth.
+
+          // delete all user auth tokens for this project.
+          await WorkspaceUserAuthTokenService.deleteBy({
+            query: {
+              projectId: authResult.projectId,
+              workspaceType: WorkspaceType.Slack,
+            },
+            limit: LIMIT_MAX,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          await WorkspaceProjectAuthTokenService.deleteBy({
+            query: {
+              projectId: authResult.projectId,
+              workspaceType: WorkspaceType.Slack,
+            },
+            limit: 1,
+            skip: 0,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          logger.debug("Slack App Uninstall Request: Deleted all auth tokens.");
+          // return empty response.
+
+          return Response.sendTextResponse(req, res, "");
+        }
+
         if (authResult.isAuthorized === false) {
           // return empty response if not authorized. Do nothing in this case.
           return Response.sendTextResponse(req, res, "");
@@ -309,6 +349,34 @@ export default class SlackAPI {
               res: res,
             });
           }
+
+          if (
+            SlackAlertActions.isAlertAction({
+              actionType: action.actionType,
+            })
+          ) {
+            return SlackAlertActions.handleAlertAction({
+              slackRequest: authResult,
+              action: action,
+              req: req,
+              res: res,
+            });
+          }
+
+          if (
+            SlackScheduledMaintenanceActions.isScheduledMaintenanceAction({
+              actionType: action.actionType,
+            })
+          ) {
+            return SlackScheduledMaintenanceActions.handleScheduledMaintenanceAction(
+              {
+                slackRequest: authResult,
+                action: action,
+                req: req,
+                res: res,
+              },
+            );
+          }
         }
 
         return Response.sendErrorResponse(

package/Server/Services/AccessTokenService.ts

@@ -15,6 +15,7 @@ import TeamMember from "Common/Models/DatabaseModels/TeamMember";
 import TeamPermission from "Common/Models/DatabaseModels/TeamPermission";
 import UserPermissionUtil from "../Utils/UserPermission/UserPermission";
 import PermissionNamespace from "../Types/Permission/PermissionNamespace";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 
 export class AccessTokenService extends BaseService {
   public constructor() {
@@ -198,6 +199,26 @@ export class AccessTokenService extends BaseService {
     return permission;
   }
 
+  public async getDatabaseCommonInteractionPropsByUserAndProject(data: {
+    userId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<DatabaseCommonInteractionProps> {
+    const { userId, projectId } = data;
+
+    return {
+      userId: userId,
+      userGlobalAccessPermission:
+        (await this.getUserGlobalAccessPermission(userId)) || undefined,
+      userTenantAccessPermission: {
+        [projectId.toString()]: (await this.getUserTenantAccessPermission(
+          userId,
+          projectId,
+        ))!,
+      },
+      tenantId: projectId,
+    };
+  }
+
   public async getUserTenantAccessPermission(
     userId: ObjectID,
     projectId: ObjectID,

package/Server/Services/AlertFeedService.ts

@@ -3,12 +3,21 @@ import Color from "../../Types/Color";
 import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
 import ObjectID from "../../Types/ObjectID";
+import WorkspaceMessagePayload from "../../Types/Workspace/WorkspaceMessagePayload";
 import { IsBillingEnabled } from "../EnvironmentConfig";
 import logger from "../Utils/Logger";
+import { WorkspaceChannel } from "../Utils/Workspace/WorkspaceBase";
+import AlertService from "./AlertService";
 import DatabaseService from "./DatabaseService";
 import Model, {
   AlertFeedEventType,
 } from "Common/Models/DatabaseModels/AlertFeed";
+import WorkspaceNotificationRuleService, {
+  MessageBlocksByWorkspaceType,
+} from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import WorkspaceUtil from "../Utils/Workspace/Workspace";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -28,6 +37,13 @@ export class Service extends DatabaseService<Model> {
     displayColor?: Color | undefined;
     userId?: ObjectID | undefined;
     postedAt?: Date | undefined;
+    workspaceNotification?:
+      | {
+          notifyUserId?: ObjectID | undefined; // this is oneuptime user id.
+          sendWorkspaceNotification: boolean;
+          appendMessageBlocks?: Array<MessageBlocksByWorkspaceType> | undefined;
+        }
+      | undefined;
   }): Promise<void> {
     try {
       if (!data.alertId) {
@@ -77,6 +93,88 @@ export class Service extends DatabaseService<Model> {
           isRoot: true,
         },
       });
+
+      try {
+        // send notification to slack and teams
+        if (data.workspaceNotification?.sendWorkspaceNotification) {
+          let messageBlocksByWorkspaceTypes: Array<MessageBlocksByWorkspaceType> =
+            [];
+
+          // use markdown to create blocks
+          messageBlocksByWorkspaceTypes =
+            await WorkspaceUtil.getMessageBlocksByMarkdown({
+              userId: data.workspaceNotification.notifyUserId,
+              markdown: data.feedInfoInMarkdown,
+              projectId: data.projectId,
+            });
+
+          if (data.workspaceNotification.appendMessageBlocks) {
+            for (const messageBlocksByWorkspaceType of data
+              .workspaceNotification.appendMessageBlocks) {
+              const workspaceType: WorkspaceType =
+                messageBlocksByWorkspaceType.workspaceType;
+
+              messageBlocksByWorkspaceTypes
+                .find(
+                  (
+                    messageBlocksByWorkspaceType: MessageBlocksByWorkspaceType,
+                  ) => {
+                    return (
+                      messageBlocksByWorkspaceType.workspaceType ===
+                      workspaceType
+                    );
+                  },
+                )
+                ?.messageBlocks.push(
+                  ...messageBlocksByWorkspaceType.messageBlocks,
+                );
+            }
+          }
+
+          const workspaceNotificationPaylaods: Array<WorkspaceMessagePayload> =
+            [];
+
+          for (const messageBlocksByWorkspaceType of messageBlocksByWorkspaceTypes) {
+            const existingChannels: Array<string> =
+              await WorkspaceNotificationRuleService.getExistingChannelNamesBasedOnEventType(
+                {
+                  projectId: data.projectId,
+                  notificationRuleEventType: NotificationRuleEventType.Alert,
+                  workspaceType: messageBlocksByWorkspaceType.workspaceType,
+                },
+              );
+
+            const alertChannels: Array<WorkspaceChannel> =
+              await AlertService.getWorkspaceChannelForAlert({
+                alertId: data.alertId,
+                workspaceType: messageBlocksByWorkspaceType.workspaceType,
+              });
+
+            const workspaceMessagePayload: WorkspaceMessagePayload = {
+              _type: "WorkspaceMessagePayload",
+              workspaceType: messageBlocksByWorkspaceType.workspaceType,
+              messageBlocks: messageBlocksByWorkspaceType.messageBlocks,
+              channelNames: existingChannels,
+              channelIds:
+                alertChannels.map((channel: WorkspaceChannel) => {
+                  return channel.id;
+                }) || [],
+            };
+
+            workspaceNotificationPaylaods.push(workspaceMessagePayload);
+          }
+
+          await WorkspaceUtil.postMessageToAllWorkspaceChannelsAsBot({
+            projectId: data.projectId,
+            messagePayloadsByWorkspace: workspaceNotificationPaylaods,
+          });
+        }
+      } catch (e) {
+        logger.error("Error in sending notification to slack and teams");
+        logger.error(e);
+
+        // we dont throw this error as it is not a critical error
+      }
     } catch (error) {
       logger.error("AlertFeedService.createAlertFeedItem");
       logger.error(error);

package/Server/Services/AlertInternalNoteService.ts

@@ -6,12 +6,34 @@ import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 import { Blue500 } from "../../Types/BrandColors";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import Alert from "../../Models/DatabaseModels/Alert";
+import AlertService from "./AlertService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  public async addNote(data: {
+    userId: ObjectID;
+    alertId: ObjectID;
+    projectId: ObjectID;
+    note: string;
+  }): Promise<Model> {
+    const internalNote: Model = new Model();
+    internalNote.createdByUserId = data.userId;
+    internalNote.alertId = data.alertId;
+    internalNote.projectId = data.projectId;
+    internalNote.note = data.note;
+
+    return this.create({
+      data: internalNote,
+      props: {
+        isRoot: true,
+      },
+    });
+  }
+
   public override async onCreateSuccess(
     _onCreate: OnCreate<Model>,
     createdItem: Model,
@@ -19,6 +41,12 @@ export class Service extends DatabaseService<Model> {
     const userId: ObjectID | null | undefined =
       createdItem.createdByUserId || createdItem.createdByUser?.id;
 
+    const alertId: ObjectID = createdItem.alertId!;
+
+    const alertNumber: number | null = await AlertService.getAlertNumber({
+      alertId: alertId,
+    });
+
     await AlertFeedService.createAlertFeedItem({
       alertId: createdItem.alertId!,
       projectId: createdItem.projectId!,
@@ -26,10 +54,14 @@ export class Service extends DatabaseService<Model> {
       displayColor: Blue500,
       userId: userId || undefined,
 
-      feedInfoInMarkdown: `**Posted Internal / Private Note**
-  
-  ${createdItem.note}
-            `,
+      feedInfoInMarkdown: `📄 posted **private note** for this [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(createdItem.projectId!, alertId)).toString()}):
+      
+${createdItem.note}
+                `,
+      workspaceNotification: {
+        sendWorkspaceNotification: true,
+        notifyUserId: userId || undefined,
+      },
     });
 
     return createdItem;
@@ -52,6 +84,10 @@ export class Service extends DatabaseService<Model> {
           projectId: true,
           note: true,
           createdByUserId: true,
+          alert: {
+            projectId: true,
+            alertNumber: true,
+          },
           createdByUser: {
             _id: true,
           },
@@ -62,6 +98,7 @@ export class Service extends DatabaseService<Model> {
         onUpdate.updateBy.props.userId;
 
       for (const updatedItem of updatedItems) {
+        const alert: Alert = updatedItem.alert!;
         await AlertFeedService.createAlertFeedItem({
           alertId: updatedItem.alertId!,
           projectId: updatedItem.projectId!,
@@ -69,10 +106,14 @@ export class Service extends DatabaseService<Model> {
           displayColor: Blue500,
           userId: userId || undefined,
 
-          feedInfoInMarkdown: `**Updated Internal / Private Note**
-  
-  ${updatedItem.note}
-            `,
+          feedInfoInMarkdown: `📄 updated **Private Note** for this [Alert ${alert.alertNumber}](${(await AlertService.getAlertLinkInDashboard(alert.projectId!, alert.id!)).toString()})
+          
+${updatedItem.note}
+                    `,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: userId || undefined,
+          },
         });
       }
     }

package/Server/Services/AlertOwnerTeamService.ts

@@ -8,6 +8,11 @@ import TeamService from "./TeamService";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 import { Gray500, Red500 } from "../../Types/BrandColors";
+import AlertService from "./AlertService";
+import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -65,13 +70,20 @@ export class Service extends DatabaseService<Model> {
         });
 
         if (team && team.name) {
+          const alertNumber: number | null = await AlertService.getAlertNumber({
+            alertId: alertId,
+          });
           await AlertFeedService.createAlertFeedItem({
             alertId: alertId,
             projectId: projectId,
             alertFeedEventType: AlertFeedEventType.OwnerTeamRemoved,
             displayColor: Red500,
-            feedInfoInMarkdown: `Removed team **${team.name}** from the alert as the owner.`,
+            feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Removed team **${team.name}** from the [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
             userId: deleteByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: deleteByUserId || undefined,
+            },
           });
         }
       }
@@ -104,17 +116,53 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (team && team.name) {
+        const alertNumber: number | null = await AlertService.getAlertNumber({
+          alertId: alertId,
+        });
+
         await AlertFeedService.createAlertFeedItem({
           alertId: alertId,
           projectId: projectId,
           alertFeedEventType: AlertFeedEventType.OwnerTeamAdded,
           displayColor: Gray500,
-          feedInfoInMarkdown: `Added team **${team.name}** to the alert as the owner.`,
+          feedInfoInMarkdown: `👨🏻‍👩🏻‍👦🏻 Added team **${team.name}** to the [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
           userId: createdByUserId || undefined,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: createdByUserId || undefined,
+          },
         });
       }
     }
 
+    // get notification rule where inviteOwners is true.
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await WorkspaceNotificationRuleService.getNotificationRulesWhereInviteOwnersIsTrue(
+        {
+          projectId: projectId!,
+          notificationFor: {
+            alertId: alertId,
+          },
+          notificationRuleEventType: NotificationRuleEventType.Alert,
+        },
+      );
+
+    logger.debug(`Notification Rules for Alert Owner Teams`);
+    logger.debug(notificationRules);
+
+    WorkspaceNotificationRuleService.inviteTeamsBasedOnRulesAndWorkspaceChannels(
+      {
+        notificationRules: notificationRules,
+        projectId: projectId!,
+        workspaceChannels: await AlertService.getWorkspaceChannelForAlert({
+          alertId: alertId!,
+        }),
+        teamIds: [teamId!],
+      },
+    ).catch((error: Error) => {
+      logger.error(error);
+    });
+
     return createdItem;
   }
 }

package/Server/Services/AlertOwnerUserService.ts

@@ -8,6 +8,11 @@ import UserService from "./UserService";
 import AlertFeedService from "./AlertFeedService";
 import { AlertFeedEventType } from "../../Models/DatabaseModels/AlertFeed";
 import { Gray500, Red500 } from "../../Types/BrandColors";
+import AlertService from "./AlertService";
+import WorkspaceNotificationRule from "../../Models/DatabaseModels/WorkspaceNotificationRule";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import logger from "../Utils/Logger";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -66,13 +71,21 @@ export class Service extends DatabaseService<Model> {
         });
 
         if (user && user.name) {
+          const alertNumber: number | null = await AlertService.getAlertNumber({
+            alertId: alertId,
+          });
+
           await AlertFeedService.createAlertFeedItem({
             alertId: alertId,
             projectId: projectId,
             alertFeedEventType: AlertFeedEventType.OwnerUserRemoved,
             displayColor: Red500,
-            feedInfoInMarkdown: `Removed **${user.name.toString()}** (${user.email?.toString()}) from the alert as the owner.`,
+            feedInfoInMarkdown: `👨🏻‍💻 Removed **${user.name.toString()}** (${user.email?.toString()}) from the [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
             userId: deleteByUserId || undefined,
+            workspaceNotification: {
+              sendWorkspaceNotification: true,
+              notifyUserId: userId || undefined,
+            },
           });
         }
       }
@@ -106,17 +119,54 @@ export class Service extends DatabaseService<Model> {
       });
 
       if (user && user.name) {
+        const alertNumber: number | null = await AlertService.getAlertNumber({
+          alertId: alertId,
+        });
         await AlertFeedService.createAlertFeedItem({
           alertId: alertId,
           projectId: projectId,
           alertFeedEventType: AlertFeedEventType.OwnerUserAdded,
           displayColor: Gray500,
-          feedInfoInMarkdown: `**${user.name.toString()}** (${user.email?.toString()}) was added to the alert as the owner.`,
+          feedInfoInMarkdown: `👨🏻‍💻 Added **${await UserService.getUserMarkdownString(
+            {
+              userId: userId,
+              projectId: projectId,
+            },
+          )}** to the [Alert ${alertNumber}](${(await AlertService.getAlertLinkInDashboard(projectId!, alertId!)).toString()}) as the owner.`,
           userId: createdByUserId || undefined,
+          workspaceNotification: {
+            sendWorkspaceNotification: true,
+            notifyUserId: userId || undefined,
+          },
         });
       }
     }
 
+    // get notification rule where inviteOwners is true.
+    const notificationRules: Array<WorkspaceNotificationRule> =
+      await WorkspaceNotificationRuleService.getNotificationRulesWhereInviteOwnersIsTrue(
+        {
+          projectId: projectId!,
+          notificationFor: {
+            alertId: alertId,
+          },
+          notificationRuleEventType: NotificationRuleEventType.Alert,
+        },
+      );
+
+    WorkspaceNotificationRuleService.inviteUsersBasedOnRulesAndWorkspaceChannels(
+      {
+        notificationRules: notificationRules,
+        projectId: projectId!,
+        workspaceChannels: await AlertService.getWorkspaceChannelForAlert({
+          alertId: alertId!,
+        }),
+        userIds: [userId!],
+      },
+    ).catch((error: Error) => {
+      logger.error(error);
+    });
+
     return createdItem;
   }
 }