@oneuptime/common 7.0.3718 → 7.0.3815

package/Models/DatabaseModels/Alert.ts

@@ -36,7 +36,7 @@ import {
   ManyToOne,
 } from "typeorm";
 import { TelemetryQuery } from "../../Types/Telemetry/TelemetryQuery";
-import { WorkspaceChannel } from "../../Server/Utils/Workspace/WorkspaceBase";
+import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
 
 @EnableDocumentation()
 @AccessControlColumn("labels")
@@ -1053,5 +1053,6 @@ export default class Alert extends BaseModel {
     type: ColumnType.JSON,
     nullable: true,
   })
-  public postUpdatesToWorkspaceChannels?: Array<WorkspaceChannel> = undefined;
+  public postUpdatesToWorkspaceChannels?: Array<NotificationRuleWorkspaceChannel> =
+    undefined;
 }

package/Models/DatabaseModels/Incident.ts

@@ -37,7 +37,7 @@ import {
   ManyToOne,
 } from "typeorm";
 import { TelemetryQuery } from "../../Types/Telemetry/TelemetryQuery";
-import { WorkspaceChannel } from "../../Server/Utils/Workspace/WorkspaceBase";
+import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
 
 @EnableDocumentation()
 @AccessControlColumn("labels")
@@ -1138,7 +1138,8 @@ export default class Incident extends BaseModel {
     type: ColumnType.JSON,
     nullable: true,
   })
-  public postUpdatesToWorkspaceChannels?: Array<WorkspaceChannel> = undefined;
+  public postUpdatesToWorkspaceChannels?: Array<NotificationRuleWorkspaceChannel> =
+    undefined;
 
   @ColumnAccessControl({
     create: [

package/Models/DatabaseModels/Index.ts

@@ -165,6 +165,7 @@ import WorkspaceUserAuthToken from "./WorkspaceUserAuthToken";
 import WorkspaceProjectAuthToken from "./WorkspaceProjectAuthToken";
 import WorkspaceSetting from "./WorkspaceSetting";
 import WorkspaceNotificationRule from "./WorkspaceNotificationRule";
+import ProjectUser from "./ProjectUser";
 
 const AllModelTypes: Array<{
   new (): BaseModel;
@@ -353,6 +354,8 @@ const AllModelTypes: Array<{
 
   WorkspaceSetting,
   WorkspaceNotificationRule,
+
+  ProjectUser,
 ];
 
 const modelTypeMap: { [key: string]: { new (): BaseModel } } = {};

package/Models/DatabaseModels/ProjectUser.ts

@@ -0,0 +1,335 @@
+import Project from "./Project";
+import Team from "./Team";
+import User from "./User";
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import Route from "../../Types/API/Route";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import AllowUserQueryWithoutTenant from "../../Types/Database/AllowUserQueryWithoutTenant";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import CurrentUserCanAccessRecordBy from "../../Types/Database/CurrentUserCanAccessRecordBy";
+import MultiTenentQueryAllowed from "../../Types/Database/MultiTenentQueryAllowed";
+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,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+} from "typeorm";
+
+@TableAccessControl({
+  create: [],
+  read: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.ReadProjectTeam,
+    Permission.CurrentUser,
+  ],
+  delete: [],
+  update: [],
+})
+@MultiTenentQueryAllowed(true)
+@AllowUserQueryWithoutTenant(true)
+@CurrentUserCanAccessRecordBy("userId")
+@TenantColumn("projectId")
+@CrudApiEndpoint(new Route("/project-user"))
+@Entity({
+  name: "ProjectUser",
+})
+@TableMetadata({
+  tableName: "ProjectUser",
+  singularName: "User",
+  pluralName: "Users",
+  icon: IconProp.User,
+  tableDescription:
+    "This model connects users and teams. This is an internal table. Its a view on TeamMembers table.",
+})
+export default class ProjectUser extends BaseModel {
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectTeam,
+      Permission.CurrentUser,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: Team,
+    title: "Teams",
+    description: "Teams to which this user belongs.",
+  })
+  @ManyToMany(
+    () => {
+      return Team;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "ProjectUserAcceptedTeams",
+    inverseJoinColumn: {
+      name: "teamId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "projectUserId",
+      referencedColumnName: "_id",
+    },
+  })
+  public acceptedTeams?: Array<Team> = undefined; // user is accepted to these teams. This is a view on TeamMembers table.
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectTeam,
+      Permission.CurrentUser,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.EntityArray,
+    modelType: Team,
+    title: "Teams",
+    description: "Teams to which this user belongs.",
+  })
+  @ManyToMany(
+    () => {
+      return Team;
+    },
+    { eager: false },
+  )
+  @JoinTable({
+    name: "ProjectUserInvitedTeams",
+    inverseJoinColumn: {
+      name: "teamId",
+      referencedColumnName: "_id",
+    },
+    joinColumn: {
+      name: "projectUserId",
+      referencedColumnName: "_id",
+    },
+  })
+  public invitedTeams?: Array<Team> = undefined; // user is invited to these teams.
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectTeam,
+      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: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectTeam,
+      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({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ReadProjectTeam,
+      Permission.ProjectMember,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "userId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "User",
+    description: "User who belongs to this team.",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: false,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "userId" })
+  public user?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectTeam,
+      Permission.CurrentUser,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    title: "User ID",
+    description: "ID of User who belongs to this team",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public userId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    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: [],
+    read: [],
+    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",
+    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;
+}

package/Models/DatabaseModels/ScheduledMaintenance.ts

@@ -35,7 +35,7 @@ import {
   ManyToOne,
 } from "typeorm";
 import Recurring from "../../Types/Events/Recurring";
-import { WorkspaceChannel } from "../../Server/Utils/Workspace/WorkspaceBase";
+import NotificationRuleWorkspaceChannel from "../../Types/Workspace/NotificationRules/NotificationRuleWorkspaceChannel";
 
 @EnableDocumentation()
 @AccessControlColumn("labels")
@@ -997,7 +997,8 @@ export default class ScheduledMaintenance extends BaseModel {
     type: ColumnType.JSON,
     nullable: true,
   })
-  public postUpdatesToWorkspaceChannels?: Array<WorkspaceChannel> = undefined;
+  public postUpdatesToWorkspaceChannels?: Array<NotificationRuleWorkspaceChannel> =
+    undefined;
 
   @ColumnAccessControl({
     create: [

package/Server/API/SlackAPI.ts

@@ -12,6 +12,8 @@ import BadDataException from "../../Types/Exception/BadDataException";
 import {
   AppApiClientUrl,
   DashboardClientUrl,
+  Host,
+  HttpProtocol,
   SlackAppClientId,
   SlackAppClientSecret,
 } from "../EnvironmentConfig";
@@ -24,6 +26,13 @@ import WorkspaceProjectAuthTokenService from "../Services/WorkspaceProjectAuthTo
 import ObjectID from "../../Types/ObjectID";
 import WorkspaceUserAuthTokenService from "../Services/WorkspaceUserAuthTokenService";
 import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+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 {
@@ -33,7 +42,23 @@ export default class SlackAPI {
       "/slack/app-manifest",
       (req: ExpressRequest, res: ExpressResponse) => {
         // return app manifest for slack app
-        return Response.sendJsonObjectResponse(req, res, SlackAppManifest);
+
+        let ServerURL: string = new URL(HttpProtocol, Host).toString();
+
+        //remove trailing slash if present.
+        if (ServerURL.endsWith("/")) {
+          ServerURL = ServerURL.slice(0, -1);
+        }
+
+        // replace SERVER_URL in the manifest with the actual server url.
+        const manifestInString: string = JSON.stringify(
+          SlackAppManifest,
+        ).replace(/{{SERVER_URL}}/g, ServerURL.toString());
+
+        // convert it back to json.
+        const manifest: JSONObject = JSON.parse(manifestInString);
+
+        return Response.sendJsonObjectResponse(req, res, manifest);
       },
     );
 
@@ -251,108 +276,107 @@ export default class SlackAPI {
     router.post(
       "/slack/interactive",
       SlackAuthorization.isAuthorizedSlackRequest,
-      (req: ExpressRequest, res: ExpressResponse) => {
-        return Response.sendJsonObjectResponse(req, res, {
-          response_action: "clear",
-        });
-      },
-    );
-
-    // options load endpoint.
+      async (req: ExpressRequest, res: ExpressResponse) => {
+        logger.debug("Slack Interactive Request: ");
 
-    router.post(
-      "/slack/options-load",
-      SlackAuthorization.isAuthorizedSlackRequest,
-      (req: ExpressRequest, res: ExpressResponse) => {
-        return Response.sendJsonObjectResponse(req, res, {
-          response_action: "clear",
+        const authResult: SlackRequest = await SlackAuthAction.isAuthorized({
+          req: req,
         });
-      },
-    );
 
-    router.post(
-      "/slack/command",
-      SlackAuthorization.isAuthorizedSlackRequest,
-      (req: ExpressRequest, res: ExpressResponse) => {
-        return Response.sendJsonObjectResponse(req, res, {
-          response_action: "clear",
-        });
-      },
-    );
+        logger.debug("Slack Interactive Auth Result: ");
+        logger.debug(authResult);
 
-    router.post(
-      "/slack/events",
-      SlackAuthorization.isAuthorizedSlackRequest,
-      (req: ExpressRequest, res: ExpressResponse) => {
-        // respond to slack challenge
+        // if slack uninstall app then,
+        if (authResult.payloadType === "app_uninstall") {
+          logger.debug("Slack App Uninstall Request: ");
 
-        const body: any = req.body;
+          // remove the project auth and user auth.
 
-        if (body.challenge) {
-          return Response.sendJsonObjectResponse(req, res, {
-            challenge: body.challenge,
+          // 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 event is "create-incident" then show the incident create modal with title and description and add a button to submit the form.
+        if (authResult.isAuthorized === false) {
+          // return empty response if not authorized. Do nothing in this case.
+          return Response.sendTextResponse(req, res, "");
+        }
 
-        if (body.event && body.event.type === "create-incident") {
-          return Response.sendJsonObjectResponse(req, res, {
-            type: "modal",
-            title: {
-              type: "plain_text",
-              text: "Create Incident",
-            },
-            blocks: [
-              {
-                type: "input",
-                block_id: "title",
-                element: {
-                  type: "plain_text_input",
-                  action_id: "title",
-                  placeholder: {
-                    type: "plain_text",
-                    text: "Incident Title",
-                  },
-                },
-                label: {
-                  type: "plain_text",
-                  text: "Title",
-                },
-              },
+        for (const action of authResult.actions || []) {
+          if (!action.actionType) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadRequestException("Invalid request"),
+            );
+          }
+
+          if (
+            SlackIncidentActions.isIncidentAction({
+              actionType: action.actionType,
+            })
+          ) {
+            return SlackIncidentActions.handleIncidentAction({
+              slackRequest: authResult,
+              action: action,
+              req: req,
+              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(
               {
-                type: "input",
-                block_id: "description",
-                element: {
-                  type: "plain_text_input",
-                  action_id: "description",
-                  placeholder: {
-                    type: "plain_text",
-                    text: "Incident Description",
-                  },
-                },
-                label: {
-                  type: "plain_text",
-                  text: "Description",
-                },
+                slackRequest: authResult,
+                action: action,
+                req: req,
+                res: res,
               },
-              // button
-              {
-                type: "actions",
-                elements: [
-                  {
-                    type: "button",
-                    text: {
-                      type: "plain_text",
-                      text: "Submit",
-                    },
-                    style: "primary",
-                    value: "submit",
-                  },
-                ],
-              },
-            ],
-          });
+            );
+          }
         }
 
         return Response.sendErrorResponse(
@@ -363,6 +387,18 @@ export default class SlackAPI {
       },
     );
 
+    // options load endpoint.
+
+    router.post(
+      "/slack/options-load",
+      SlackAuthorization.isAuthorizedSlackRequest,
+      (req: ExpressRequest, res: ExpressResponse) => {
+        return Response.sendJsonObjectResponse(req, res, {
+          response_action: "clear",
+        });
+      },
+    );
+
     return router;
   }
 }

package/Server/Infrastructure/Postgres/SchemaMigrations/1740597525803-MigrationName.ts

@@ -0,0 +1,17 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1740597525803 implements MigrationInterface {
+  public name = "MigrationName1740597525803";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Incident" ADD "workspaceThreadIds" jsonb`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Incident" DROP COLUMN "workspaceThreadIds"`,
+    );
+  }
+}