@oneuptime/common 12.0.18 → 12.0.19

package/Models/DatabaseModels/UserNotificationSetting.ts

@@ -314,6 +314,40 @@ class UserNotificationSetting extends BaseModel {
   })
   public alertByTelegram?: boolean = undefined;
 
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [Permission.CurrentUser],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    defaultValue: false,
+    example: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    default: false,
+  })
+  public alertBySlack?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [Permission.CurrentUser],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    defaultValue: false,
+    example: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    default: false,
+  })
+  public alertByMicrosoftTeams?: boolean = undefined;
+
   @ColumnAccessControl({
     create: [Permission.CurrentUser],
     read: [Permission.CurrentUser],

package/Models/DatabaseModels/UserOnCallLogTimeline.ts

@@ -16,6 +16,8 @@ import UserPush from "./UserPush";
 import UserOnCallLog from "./UserOnCallLog";
 import UserSMS from "./UserSMS";
 import UserTelegram from "./UserTelegram";
+import UserSlack from "./UserSlack";
+import UserMicrosoftTeams from "./UserMicrosoftTeams";
 import UserWebhook from "./UserWebhook";
 import UserWhatsApp from "./UserWhatsApp";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
@@ -1057,6 +1059,99 @@ export default class UserOnCallLogTimeline extends BaseModel {
   })
   public userTelegramId?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "userSlackId",
+    type: TableColumnType.Entity,
+    modelType: UserSlack,
+    title: "User Slack",
+    description: "Relation to User Slack Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return UserSlack;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "userSlackId" })
+  public userSlack?: UserSlack = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "User Slack ID",
+    description: "ID of User Slack in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public userSlackId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "userMicrosoftTeamsId",
+    type: TableColumnType.Entity,
+    modelType: UserMicrosoftTeams,
+    title: "User Microsoft Teams",
+    description:
+      "Relation to User Microsoft Teams Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return UserMicrosoftTeams;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "userMicrosoftTeamsId" })
+  public userMicrosoftTeams?: UserMicrosoftTeams = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "User Microsoft Teams ID",
+    description: "ID of User Microsoft Teams in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public userMicrosoftTeamsId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [Permission.CurrentUser],

package/Models/DatabaseModels/UserSlack.ts

@@ -0,0 +1,341 @@
+import Project from "./Project";
+import User from "./User";
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import Route from "../../Types/API/Route";
+import AllowAccessIfSubscriptionIsUnpaid from "../../Types/Database/AccessControl/AllowAccessIfSubscriptionIsUnpaid";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import OwnerOnlyColumn from "../../Types/Database/AccessControl/OwnerOnlyColumn";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import ColumnLength from "../../Types/Database/ColumnLength";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import CurrentUserCanAccessRecordBy from "../../Types/Database/CurrentUserCanAccessRecordBy";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import TenantColumn from "../../Types/Database/TenantColumn";
+import IconProp from "../../Types/Icon/IconProp";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+
+/*
+ * `read` names Permission.CurrentUser and nothing else, exactly like the other
+ * notification-method models (UserTelegram has the full essay). That single
+ * entry is what keeps every row owner-only: row scoping comes from the TABLE
+ * list alone, and widening it would expose the Slack member id every project
+ * member's pages are delivered to. Do not add administrator permissions here -
+ * OnCallReadinessService returns the masked, admin-sanctioned view instead.
+ *
+ * Unlike Telegram/SMS/WhatsApp there is no verification code: a row is only
+ * ever created from an existing, OAuth-established workspace link
+ * (WorkspaceUserAuthToken), so creation IS verification. UserSlackService
+ * enforces that and stamps the Slack identifiers server-side.
+ */
+@TenantColumn("projectId")
+@AllowAccessIfSubscriptionIsUnpaid()
+@TableAccessControl({
+  create: [Permission.CurrentUser],
+  read: [Permission.CurrentUser],
+  delete: [Permission.CurrentUser],
+  update: [Permission.CurrentUser],
+})
+@CrudApiEndpoint(new Route("/user-slack"))
+@Entity({
+  name: "UserSlack",
+})
+@TableMetadata({
+  tableName: "UserSlack",
+  singularName: "Slack Account",
+  pluralName: "Slack Accounts",
+  icon: IconProp.Slack,
+  tableDescription: "Slack accounts used for Slack notifications.",
+})
+@CurrentUserCanAccessRecordBy("userId")
+class UserSlack extends BaseModel {
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "projectId",
+    type: TableColumnType.Entity,
+    modelType: Project,
+    title: "Project",
+    description: "Relation to Project Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return Project;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "projectId" })
+  public project?: Project = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Project ID",
+    description: "ID of your OneUptime Project in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public projectId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * CurrentUser here does NOT mean the client may choose the value: the
+     * service hook refuses any non-root payload that carries these columns
+     * and then stamps them itself, and hooks run BEFORE the column
+     * permission check (DatabaseService.create). The entry exists because
+     * that same check runs on the STAMPED data - with an empty list the
+     * server's own write is refused and no user can add this method at all.
+     * Same shape as UserWebAuthn's server-stamped isVerified.
+     */
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @Index()
+  /*
+   * The Slack member id (e.g. U0123ABCD) the project's bot delivers direct
+   * messages to. Holding it is enough to address bot messages at that person,
+   * so it is a delivery target and not a label. Captured server-side from the
+   * user's own WorkspaceUserAuthToken - never writable by the client.
+   */
+  @OwnerOnlyColumn()
+  @TableColumn({
+    title: "Slack User ID",
+    required: false,
+    unique: false,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    description:
+      "Slack member ID captured from your connected Slack account. Populated automatically.",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    unique: false,
+    nullable: true,
+  })
+  public slackUserId?: string = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * CurrentUser here does NOT mean the client may choose the value: the
+     * service hook refuses any non-root payload that carries these columns
+     * and then stamps them itself, and hooks run BEFORE the column
+     * permission check (DatabaseService.create). The entry exists because
+     * that same check runs on the STAMPED data - with an empty list the
+     * server's own write is refused and no user can add this method at all.
+     * Same shape as UserWebAuthn's server-stamped isVerified.
+     */
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  /*
+   * The person's Slack display name at the time the method was added. Only a
+   * label for the row, but it is still their identity in an outside workspace,
+   * so it stays owner-only like the Telegram handle.
+   */
+  @OwnerOnlyColumn()
+  @TableColumn({
+    title: "Slack Username",
+    required: false,
+    unique: false,
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: true,
+    description:
+      "Slack username captured from your connected Slack account. Populated automatically.",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    unique: false,
+    nullable: true,
+  })
+  public slackUserName?: string = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "user",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "User",
+    description: "Relation to User who this Slack account belongs to",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "userId" })
+  public user?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "User ID",
+    description: "User ID who this Slack account belongs to",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  @Index()
+  public userId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "createdByUserId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "Created by User",
+    description:
+      "Relation to User who created this object (if this object was created by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "createdByUserId" })
+  public createdByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Created by User ID",
+    description:
+      "User ID who created this object (if this object was created by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public createdByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "deletedByUserId",
+    type: TableColumnType.Entity,
+    title: "Deleted by User",
+    modelType: User,
+    description:
+      "Relation to User who deleted this object (if this object was deleted by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      cascade: false,
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "deletedByUserId" })
+  public deletedByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Deleted by User ID",
+    description:
+      "User ID who deleted this object (if this object was deleted by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public deletedByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    /*
+     * CurrentUser here does NOT mean the client may choose the value: the
+     * service hook refuses any non-root payload that carries these columns
+     * and then stamps them itself, and hooks run BEFORE the column
+     * permission check (DatabaseService.create). The entry exists because
+     * that same check runs on the STAMPED data - with an empty list the
+     * server's own write is refused and no user can add this method at all.
+     * Same shape as UserWebAuthn's server-stamped isVerified.
+     */
+    create: [Permission.CurrentUser],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    title: "Is Verified",
+    description: "Is this Slack account verified?",
+    isDefaultValueColumn: true,
+    type: TableColumnType.Boolean,
+    defaultValue: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    default: false,
+  })
+  public isVerified?: boolean = undefined;
+}
+
+export default UserSlack;

package/Models/DatabaseModels/WorkspaceProjectAuthToken.ts

@@ -34,6 +34,15 @@ export interface MicrosoftTeamsChat {
   chatType: MicrosoftTeamsChatType;
   serviceUrl?: string | undefined; // Bot Framework service URL captured when the bot was added.
   addedAt?: string | undefined;
+  /*
+   * Microsoft Entra object ids of the human members, captured from the chat
+   * roster. What lets a personal chat be matched back to the OneUptime user
+   * it belongs to (WorkspaceUserAuthToken.workspaceUserId is the same id), so
+   * user direct-message notifications can reuse the existing chat instead of
+   * creating a new conversation. Absent on records captured before this
+   * shipped.
+   */
+  memberAadObjectIds?: Array<string> | undefined;
 }
 
 /*

package/Server/API/UserMicrosoftTeamsAPI.ts

@@ -0,0 +1,127 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import UserMicrosoftTeamsService, {
+  Service as UserMicrosoftTeamsServiceType,
+} from "../Services/UserMicrosoftTeamsService";
+import WorkspaceUserNotificationService from "../Services/WorkspaceUserNotificationService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+  OneUptimeRequest,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import BadDataException from "../../Types/Exception/BadDataException";
+import UserMicrosoftTeams from "../../Models/DatabaseModels/UserMicrosoftTeams";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import { WorkspacePayloadMarkdown } from "../../Types/Workspace/WorkspaceMessagePayload";
+
+export default class UserMicrosoftTeamsAPI extends BaseAPI<
+  UserMicrosoftTeams,
+  UserMicrosoftTeamsServiceType
+> {
+  public constructor() {
+    super(UserMicrosoftTeams, UserMicrosoftTeamsService);
+
+    /*
+     * Sends a test direct message to the caller's own linked Microsoft Teams
+     * account. Worth a click on this channel more than any other: a Teams DM
+     * needs the OneUptime app installed for the user, and this surfaces the
+     * actionable "install the app" error before a real page depends on it.
+     */
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/test`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          req = req as OneUptimeRequest;
+
+          if (!req.body["itemId"]) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid item ID"),
+            );
+          }
+
+          const item: UserMicrosoftTeams | null =
+            await this.service.findOneById({
+              id: req.body["itemId"],
+              props: {
+                isRoot: true,
+              },
+              select: {
+                userId: true,
+                projectId: true,
+                microsoftTeamsUserId: true,
+                isVerified: true,
+              },
+            });
+
+          if (!item) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Item not found"),
+            );
+          }
+
+          if (
+            item.userId?.toString() !==
+            (req as OneUptimeRequest)?.userAuthorization?.userId?.toString()
+          ) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid user ID"),
+            );
+          }
+
+          if (!item.microsoftTeamsUserId || !item.isVerified) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                "This Microsoft Teams account is not verified. Please remove it and add it again.",
+              ),
+            );
+          }
+
+          const markdownBlock: WorkspacePayloadMarkdown = {
+            _type: "WorkspacePayloadMarkdown",
+            text: "👋 This is a OneUptime test notification. Your Microsoft Teams account can receive on-call notifications.",
+          };
+
+          try {
+            await WorkspaceUserNotificationService.sendDirectMessageToUser({
+              projectId: item.projectId!,
+              workspaceType: WorkspaceType.MicrosoftTeams,
+              workspaceUserId: item.microsoftTeamsUserId,
+              messageBlocks: [markdownBlock],
+              messageSummary: "Test notification",
+              userId: item.userId!,
+            });
+          } catch (err) {
+            const message: string =
+              err instanceof Error && err.message
+                ? err.message
+                : "Unknown error sending test Microsoft Teams message.";
+
+            return Response.sendJsonObjectResponse(req, res, {
+              ok: false,
+              statusMessage: message,
+            });
+          }
+
+          return Response.sendJsonObjectResponse(req, res, {
+            ok: true,
+            statusMessage:
+              "Test message sent. Check your Microsoft Teams chats.",
+          });
+        } catch (err) {
+          return next(err);
+        }
+      },
+    );
+  }
+}