@oneuptime/common 12.0.17 → 12.0.19

package/Server/Services/UserNotificationSettingService.ts

@@ -13,10 +13,13 @@ import UserEmailService from "./UserEmailService";
 import UserSmsService from "./UserSmsService";
 import PushNotificationService from "./PushNotificationService";
 import UserTelegramService from "./UserTelegramService";
+import UserSlackService from "./UserSlackService";
+import UserMicrosoftTeamsService from "./UserMicrosoftTeamsService";
 import UserWebhookService from "./UserWebhookService";
 import UserWhatsAppService from "./UserWhatsAppService";
 import WebhookService from "./WebhookService";
 import WhatsAppService from "./WhatsAppService";
+import WorkspaceUserNotificationService from "./WorkspaceUserNotificationService";
 import { CallRequestMessage } from "../../Types/Call/CallRequest";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import { EmailEnvelope } from "../../Types/Email/EmailMessage";
@@ -39,8 +42,15 @@ import UserEmail from "../../Models/DatabaseModels/UserEmail";
 import UserNotificationSetting from "../../Models/DatabaseModels/UserNotificationSetting";
 import UserSMS from "../../Models/DatabaseModels/UserSMS";
 import UserTelegram from "../../Models/DatabaseModels/UserTelegram";
+import UserSlack from "../../Models/DatabaseModels/UserSlack";
+import UserMicrosoftTeams from "../../Models/DatabaseModels/UserMicrosoftTeams";
 import UserWebhook from "../../Models/DatabaseModels/UserWebhook";
 import UserWhatsApp from "../../Models/DatabaseModels/UserWhatsApp";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import {
+  WorkspaceMessageBlock,
+  WorkspacePayloadMarkdown,
+} from "../../Types/Workspace/WorkspaceMessagePayload";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { appendRecipientToWhatsAppMessage } from "../Utils/WhatsAppTemplateUtil";
 
@@ -93,6 +103,8 @@ export class Service extends DatabaseService<UserNotificationSetting> {
           alertBySMS: true,
           alertByWhatsApp: true,
           alertByTelegram: true,
+          alertBySlack: true,
+          alertByMicrosoftTeams: true,
           alertByCall: true,
           alertByPush: true,
           alertByWebhook: true,
@@ -370,6 +382,132 @@ export class Service extends DatabaseService<UserNotificationSetting> {
         }
       }
 
+      if (
+        notificationSettings.alertBySlack ||
+        notificationSettings.alertByMicrosoftTeams
+      ) {
+        /*
+         * Slack and Microsoft Teams share one derived message: callers hand
+         * this method channel payloads for the older channels only, so the
+         * workspace body is synthesised from the email subject + SMS body the
+         * same way the Telegram fallback body is. Standard markdown — Slack
+         * slackifies it and Teams renders it into an adaptive card.
+         */
+        const subject: string = data.emailEnvelope.subject || "";
+        const smsBody: string = data.smsMessage.message || "";
+
+        let workspaceMarkdown: string = "";
+
+        if (subject || smsBody) {
+          const lines: Array<string> = [];
+          lines.push(`🔔 **${subject || "OneUptime notification"}**`);
+          if (smsBody) {
+            lines.push("");
+            lines.push(smsBody);
+          }
+          workspaceMarkdown = lines.join("\n");
+        }
+
+        if (!workspaceMarkdown) {
+          logger.warn(
+            "Skipping workspace notification because message body is empty.",
+          );
+        } else {
+          const markdownBlock: WorkspacePayloadMarkdown = {
+            _type: "WorkspacePayloadMarkdown",
+            text: workspaceMarkdown,
+          };
+          const messageBlocks: Array<WorkspaceMessageBlock> = [markdownBlock];
+
+          if (notificationSettings.alertBySlack) {
+            const userSlacks: Array<UserSlack> = await UserSlackService.findBy({
+              query: {
+                userId: data.userId,
+                projectId: data.projectId,
+                isVerified: true,
+              },
+              select: {
+                slackUserId: true,
+              },
+              limit: LIMIT_PER_PROJECT,
+              skip: 0,
+              props: {
+                isRoot: true,
+              },
+            });
+
+            for (const userSlack of userSlacks) {
+              if (!userSlack.slackUserId) {
+                continue;
+              }
+
+              WorkspaceUserNotificationService.sendDirectMessageToUser({
+                projectId: data.projectId,
+                workspaceType: WorkspaceType.Slack,
+                workspaceUserId: userSlack.slackUserId,
+                messageBlocks: messageBlocks,
+                messageSummary: subject || smsBody,
+                userId: data.userId,
+                incidentId: data.incidentId,
+                alertId: data.alertId,
+                alertEpisodeId: data.alertEpisodeId,
+                incidentEpisodeId: data.incidentEpisodeId,
+                teamId: data.teamId,
+                onCallPolicyId: data.onCallPolicyId,
+                onCallPolicyEscalationRuleId: data.onCallPolicyEscalationRuleId,
+                onCallScheduleId: data.onCallScheduleId,
+              }).catch((err: Error) => {
+                logger.error(err);
+              });
+            }
+          }
+
+          if (notificationSettings.alertByMicrosoftTeams) {
+            const userMicrosoftTeamsAccounts: Array<UserMicrosoftTeams> =
+              await UserMicrosoftTeamsService.findBy({
+                query: {
+                  userId: data.userId,
+                  projectId: data.projectId,
+                  isVerified: true,
+                },
+                select: {
+                  microsoftTeamsUserId: true,
+                },
+                limit: LIMIT_PER_PROJECT,
+                skip: 0,
+                props: {
+                  isRoot: true,
+                },
+              });
+
+            for (const userMicrosoftTeams of userMicrosoftTeamsAccounts) {
+              if (!userMicrosoftTeams.microsoftTeamsUserId) {
+                continue;
+              }
+
+              WorkspaceUserNotificationService.sendDirectMessageToUser({
+                projectId: data.projectId,
+                workspaceType: WorkspaceType.MicrosoftTeams,
+                workspaceUserId: userMicrosoftTeams.microsoftTeamsUserId,
+                messageBlocks: messageBlocks,
+                messageSummary: subject || smsBody,
+                userId: data.userId,
+                incidentId: data.incidentId,
+                alertId: data.alertId,
+                alertEpisodeId: data.alertEpisodeId,
+                incidentEpisodeId: data.incidentEpisodeId,
+                teamId: data.teamId,
+                onCallPolicyId: data.onCallPolicyId,
+                onCallPolicyEscalationRuleId: data.onCallPolicyEscalationRuleId,
+                onCallScheduleId: data.onCallScheduleId,
+              }).catch((err: Error) => {
+                logger.error(err);
+              });
+            }
+          }
+        }
+      }
+
       if (notificationSettings.alertByCall) {
         const userCalls: Array<UserCall> = await UserCallService.findBy({
           query: {

package/Server/Services/UserService.ts

@@ -42,6 +42,8 @@ import TeamMember from "../../Models/DatabaseModels/TeamMember";
 import Model from "../../Models/DatabaseModels/User";
 import SlackUtil from "../Utils/Workspace/Slack/Slack";
 import ProductAnalytics from "../Utils/ProductAnalytics";
+import MarketingEventUtil from "../Utils/Marketing/MarketingEventUtil";
+import { MarketingEventType } from "../../Types/Marketing/MarketingEvent";
 import UserTotpAuthService from "./UserTotpAuthService";
 import UserWebAuthnService from "./UserWebAuthnService";
 import BadDataException from "../../Types/Exception/BadDataException";
@@ -249,6 +251,32 @@ export class Service extends DatabaseService<Model> {
           first_touch: createdItem.firstTouchAttribution || {},
         },
       });
+
+      /*
+       * The outbound sign_up conversion.
+       *
+       * Emitted here rather than from the register endpoint so a signup
+       * reached any other way still counts, and keyed on the user id so a
+       * retried delivery cannot become a second conversion.
+       *
+       * hasPassword separates a direct signup from a user created by a team
+       * invite, exactly as the analytics event above does — both are real
+       * users, only one is an acquisition, and the receiver decides which it
+       * cares about rather than us deciding for it here.
+       */
+      MarketingEventUtil.emitInBackground(
+        MarketingEventUtil.buildEvent({
+          eventType: MarketingEventType.SignUp,
+          eventId: `${MarketingEventType.SignUp}:${createdItem.id?.toString()}`,
+          occurredAt: createdItem.createdAt || new Date(),
+          email: createdItem.email.toString(),
+          attributionSource: createdItem,
+          data: {
+            userId: createdItem.id?.toString() || "",
+            hasPassword: Boolean(createdItem.password),
+          },
+        }),
+      );
     }
 
     // A place holder method used for overriding.

package/Server/Services/UserSlackService.ts

@@ -0,0 +1,218 @@
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import DatabaseService from "./DatabaseService";
+import UserNotificationRuleService, {
+  NotificationDeletionImpact,
+  NotificationMethodChannel,
+} from "./UserNotificationRuleService";
+import WorkspaceProjectAuthTokenService from "./WorkspaceProjectAuthTokenService";
+import WorkspaceUserAuthTokenService from "./WorkspaceUserAuthTokenService";
+import SlackUtil from "../Utils/Workspace/Slack/Slack";
+import logger from "../Utils/Logger";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import WorkspaceProjectAuthToken from "../../Models/DatabaseModels/WorkspaceProjectAuthToken";
+import WorkspaceUserAuthToken from "../../Models/DatabaseModels/WorkspaceUserAuthToken";
+import Model from "../../Models/DatabaseModels/UserSlack";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      select: {
+        _id: true,
+        projectId: true,
+      },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const item of itemsToDelete) {
+      await UserNotificationRuleService.deleteBy({
+        query: {
+          userSlackId: item.id!,
+          projectId: item.projectId!,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    return {
+      deleteBy,
+      carryForward: null,
+    };
+  }
+
+  /**
+   * What this user would lose if this Slack account were deleted. Ask BEFORE
+   * calling delete; nothing here refuses anything.
+   *
+   * The hook directly above deletes every UserNotificationRule that points at
+   * this account, and the foreign key is onDelete: "CASCADE" so the rows would
+   * go even if it did not.
+   */
+  @CaptureSpan()
+  public async getDeletionImpact(data: {
+    itemId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<NotificationDeletionImpact> {
+    return UserNotificationRuleService.getNotificationMethodDeletionImpact({
+      projectId: data.projectId,
+      methodType: NotificationMethodChannel.Slack,
+      methodId: data.itemId,
+    });
+  }
+
+  /*
+   * A Slack notification method is a POINTER at the user's existing workspace
+   * link, not a hand-typed address: the Slack member id is resolved from the
+   * user's own WorkspaceUserAuthToken and never accepted from the request.
+   * That is why creation IS verification — the OAuth dance that wrote the
+   * auth-token row already proved the person controls that Slack account.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    if (!createBy.props.isRoot && createBy.data.isVerified) {
+      throw new BadDataException("isVerified cannot be set to true");
+    }
+
+    if (!createBy.props.isRoot && createBy.data.slackUserId) {
+      throw new BadDataException("slackUserId cannot be set directly");
+    }
+
+    if (!createBy.data.projectId || !createBy.data.userId) {
+      throw new BadDataException("projectId and userId are required");
+    }
+
+    const projectId: ObjectID = new ObjectID(
+      createBy.data.projectId.toString(),
+    );
+    const userId: ObjectID = new ObjectID(createBy.data.userId.toString());
+
+    /*
+     * One workspace link per (user, project) means a second row would be an
+     * exact duplicate of the first.
+     */
+    const existingCount: number = (
+      await this.countBy({
+        query: {
+          projectId: projectId,
+          userId: userId,
+        },
+        props: {
+          isRoot: true,
+        },
+      })
+    ).toNumber();
+
+    if (existingCount > 0) {
+      throw new BadDataException(
+        "Slack is already added as a notification method for this project.",
+      );
+    }
+
+    const projectAuth: WorkspaceProjectAuthToken | null =
+      await WorkspaceProjectAuthTokenService.getProjectAuth({
+        projectId: projectId,
+        workspaceType: WorkspaceType.Slack,
+      });
+
+    if (!projectAuth || !projectAuth.authToken) {
+      throw new BadDataException(
+        "This project is not connected to Slack. Please ask a project admin to connect Slack in Project Settings > Slack Integration.",
+      );
+    }
+
+    const userAuth: WorkspaceUserAuthToken | null =
+      await WorkspaceUserAuthTokenService.getUserAuth({
+        projectId: projectId,
+        userId: userId,
+        workspaceType: WorkspaceType.Slack,
+      });
+
+    if (!userAuth || !userAuth.workspaceUserId) {
+      throw new BadDataException(
+        "Your Slack account is not connected to OneUptime for this project. Please go to User Settings > Slack Integration and connect your Slack account first.",
+      );
+    }
+
+    createBy.data.slackUserId = userAuth.workspaceUserId;
+    createBy.data.isVerified = true;
+
+    /*
+     * Display label only — best effort. A Slack API hiccup must not stop the
+     * method from being added.
+     */
+    try {
+      const slackUserName: string | null =
+        await SlackUtil.getUsernameFromUserId({
+          authToken: projectAuth.authToken,
+          userId: userAuth.workspaceUserId,
+          projectId: projectId,
+        });
+
+      if (slackUserName) {
+        createBy.data.slackUserName = slackUserName;
+      }
+    } catch (err) {
+      logger.error("Could not resolve Slack username for new UserSlack row.");
+      logger.error(err);
+    }
+
+    return {
+      createBy,
+      carryForward: null,
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    /*
+     * The row is born verified (creation is gated on the live workspace
+     * link), so default on-call rules are seeded at create time — same as
+     * webhooks.
+     */
+    if (createdItem.projectId && createdItem.userId && createdItem.id) {
+      try {
+        await UserNotificationRuleService.addDefaultNotificationRulesForVerifiedMethod(
+          {
+            projectId: createdItem.projectId,
+            userId: createdItem.userId,
+            notificationMethod: {
+              userSlackId: createdItem.id,
+            },
+          },
+        );
+      } catch (err) {
+        logger.error(err);
+      }
+    }
+
+    return createdItem;
+  }
+}
+
+export default new Service();

package/Server/Services/WorkspaceProjectAuthTokenService.ts

@@ -3,10 +3,13 @@ import WorkspaceType, {
   getWorkspaceTypeDisplayName,
 } from "../../Types/Workspace/WorkspaceType";
 import DatabaseService from "./DatabaseService";
+import WorkspaceUserAuthTokenService from "./WorkspaceUserAuthTokenService";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnDelete } from "../Types/Database/Hooks";
 import Model, {
   WorkspaceMiscData,
 } from "../../Models/DatabaseModels/WorkspaceProjectAuthToken";
-import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import LIMIT_MAX, { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import BadDataException from "../../Types/Exception/BadDataException";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger from "../Utils/Logger";
@@ -16,6 +19,69 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  /*
+   * Disconnecting a WORKSPACE disconnects every user link inside it.
+   *
+   * The dashboard's "Uninstall OneUptime from Slack / Microsoft Teams" button
+   * deletes this row through the generic CRUD path, and nothing else about
+   * the workspace survives that in a usable state: the user auth tokens were
+   * minted against this workspace's OAuth app, and the UserSlack /
+   * UserMicrosoftTeams notification methods are pointers at those links that
+   * WorkspaceUserNotificationService will deterministically refuse to send
+   * through once this row is gone ("This project is not connected to ...").
+   *
+   * Left behind, those verified-looking methods are worse than dead: the
+   * on-call fallback selects them into its zero-cost tier and stops looking,
+   * and the readiness surface keeps reporting the responder reachable. So the
+   * user tokens are deleted THROUGH THEIR SERVICE here, whose own
+   * onBeforeDelete cascades to the notification methods and their rules -
+   * returning every affected responder to the "no rule" state the
+   * verified-method fallback is built to rescue. This mirrors what the
+   * Slack-side app_uninstall webhook already did; the webhook remains for
+   * uninstalls initiated inside Slack, where this hook never fires.
+   */
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      select: {
+        _id: true,
+        projectId: true,
+        workspaceType: true,
+      },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const item of itemsToDelete) {
+      if (!item.projectId || !item.workspaceType) {
+        continue;
+      }
+
+      await WorkspaceUserAuthTokenService.deleteBy({
+        query: {
+          projectId: item.projectId,
+          workspaceType: item.workspaceType,
+        },
+        limit: LIMIT_MAX,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+
+    return {
+      deleteBy,
+      carryForward: null,
+    };
+  }
+
   @CaptureSpan()
   public async getProjectAuth(data: {
     projectId: ObjectID;

package/Server/Services/WorkspaceUserAuthTokenService.ts

@@ -1,6 +1,11 @@
 import ObjectID from "../../Types/ObjectID";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
 import DatabaseService from "./DatabaseService";
+import UserSlackService from "./UserSlackService";
+import UserMicrosoftTeamsService from "./UserMicrosoftTeamsService";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { OnDelete } from "../Types/Database/Hooks";
 import Model, {
   SlackMiscData,
 } from "../../Models/DatabaseModels/WorkspaceUserAuthToken";
@@ -11,6 +16,74 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  /*
+   * A UserSlack / UserMicrosoftTeams notification method is a pointer at the
+   * workspace link being deleted here, so it goes down with it (which also
+   * deletes the notification rules routing to it, via that service's own
+   * delete hook). Leaving the method row behind would be worse than deleting
+   * it: a rule pointing at a dead link fails with an error row and no re-page,
+   * while a user with NO matching rule is rescued by the verified-method
+   * fallback.
+   */
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      select: {
+        _id: true,
+        projectId: true,
+        userId: true,
+        workspaceType: true,
+      },
+      skip: 0,
+      limit: LIMIT_MAX,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    for (const item of itemsToDelete) {
+      if (!item.projectId || !item.userId) {
+        continue;
+      }
+
+      if (item.workspaceType === WorkspaceType.Slack) {
+        await UserSlackService.deleteBy({
+          query: {
+            projectId: item.projectId,
+            userId: item.userId,
+          },
+          limit: LIMIT_MAX,
+          skip: 0,
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+
+      if (item.workspaceType === WorkspaceType.MicrosoftTeams) {
+        await UserMicrosoftTeamsService.deleteBy({
+          query: {
+            projectId: item.projectId,
+            userId: item.userId,
+          },
+          limit: LIMIT_MAX,
+          skip: 0,
+          props: {
+            isRoot: true,
+          },
+        });
+      }
+    }
+
+    return {
+      deleteBy,
+      carryForward: null,
+    };
+  }
+
   @CaptureSpan()
   public async getUserAuth(data: {
     projectId: ObjectID;