@oneuptime/common 7.0.3621 → 7.0.3652

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

@@ -0,0 +1,147 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1739209832500 implements MigrationInterface {
+  public name = "MigrationName1739209832500";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "WorkspaceUserAuthToken" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "authToken" text NOT NULL, "workspaceUserId" character varying(500) NOT NULL, "workspaceType" character varying(500) NOT NULL, "miscData" jsonb NOT NULL, "userId" uuid, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "PK_ae2f1b46b7e26f58a1f4a56b6ea" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_bee888f5782b9585e01f13455f" ON "WorkspaceUserAuthToken" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_4b7c7d1a8b2259df8c790db094" ON "WorkspaceUserAuthToken" ("userId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "WorkspaceProjectAuthToken" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "authToken" text NOT NULL, "workspaceType" character varying(500) NOT NULL, "workspaceProjectId" character varying(500) NOT NULL, "miscData" jsonb NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "PK_c0caa6a69da614ee74d8c1291da" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_73f5887268b09c0abccf04ef02" ON "WorkspaceProjectAuthToken" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "WorkspaceSetting" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "settings" jsonb NOT NULL, "workspaceType" character varying(500) NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "PK_eb98d42edd6489fbe1cf3f34515" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_c68f38e2b2b061c40209e85bf2" ON "WorkspaceSetting" ("projectId") `,
+    );
+    await queryRunner.query(
+      `CREATE TABLE "WorkspaceNotificationRule" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "name" character varying(500) NOT NULL, "description" character varying(500), "notificationRule" jsonb NOT NULL, "eventType" character varying NOT NULL, "workspaceType" character varying(500) NOT NULL, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "PK_d1485681c7695ac9841dc52a451" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_349b022afa9a50a597d6c91ec9" ON "WorkspaceNotificationRule" ("projectId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type":"Recurring","value":{"intervalType":"Day","intervalCount":{"_type":"PositiveNumber","value":1}}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type":"RestrictionTimes","value":{"restictionType":"None","dayRestrictionTimes":null,"weeklyRestrictionTimes":[]}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceUserAuthToken" ADD CONSTRAINT "FK_bee888f5782b9585e01f13455fb" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceUserAuthToken" ADD CONSTRAINT "FK_4b7c7d1a8b2259df8c790db0940" FOREIGN KEY ("userId") REFERENCES "User"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceUserAuthToken" ADD CONSTRAINT "FK_ec5cbf4536681fe4bea883c98ea" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceUserAuthToken" ADD CONSTRAINT "FK_1b2cb71eaf9e665e4556d1b1263" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceProjectAuthToken" ADD CONSTRAINT "FK_73f5887268b09c0abccf04ef02e" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceProjectAuthToken" ADD CONSTRAINT "FK_8aa5804c7a728039564bf5d967d" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceProjectAuthToken" ADD CONSTRAINT "FK_6287095997a16f1cbdd4fb24b61" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceSetting" ADD CONSTRAINT "FK_c68f38e2b2b061c40209e85bf22" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceSetting" ADD CONSTRAINT "FK_c8fdd61b95bfd0a2ca268b8c602" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceSetting" ADD CONSTRAINT "FK_cb3b7931417a4b4ee05d487b614" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceNotificationRule" ADD CONSTRAINT "FK_349b022afa9a50a597d6c91ec95" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceNotificationRule" ADD CONSTRAINT "FK_55f4e43427fc217ed32cf640a28" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceNotificationRule" ADD CONSTRAINT "FK_65ac673d16286be2dcd5229fe24" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceNotificationRule" DROP CONSTRAINT "FK_65ac673d16286be2dcd5229fe24"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceNotificationRule" DROP CONSTRAINT "FK_55f4e43427fc217ed32cf640a28"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceNotificationRule" DROP CONSTRAINT "FK_349b022afa9a50a597d6c91ec95"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceSetting" DROP CONSTRAINT "FK_cb3b7931417a4b4ee05d487b614"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceSetting" DROP CONSTRAINT "FK_c8fdd61b95bfd0a2ca268b8c602"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceSetting" DROP CONSTRAINT "FK_c68f38e2b2b061c40209e85bf22"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceProjectAuthToken" DROP CONSTRAINT "FK_6287095997a16f1cbdd4fb24b61"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceProjectAuthToken" DROP CONSTRAINT "FK_8aa5804c7a728039564bf5d967d"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceProjectAuthToken" DROP CONSTRAINT "FK_73f5887268b09c0abccf04ef02e"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceUserAuthToken" DROP CONSTRAINT "FK_1b2cb71eaf9e665e4556d1b1263"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceUserAuthToken" DROP CONSTRAINT "FK_ec5cbf4536681fe4bea883c98ea"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceUserAuthToken" DROP CONSTRAINT "FK_4b7c7d1a8b2259df8c790db0940"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceUserAuthToken" DROP CONSTRAINT "FK_bee888f5782b9585e01f13455fb"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "restrictionTimes" SET DEFAULT '{"_type": "RestrictionTimes", "value": {"restictionType": "None", "dayRestrictionTimes": null, "weeklyRestrictionTimes": []}}'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ALTER COLUMN "rotation" SET DEFAULT '{"_type": "Recurring", "value": {"intervalType": "Day", "intervalCount": {"_type": "PositiveNumber", "value": 1}}}'`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_349b022afa9a50a597d6c91ec9"`,
+    );
+    await queryRunner.query(`DROP TABLE "WorkspaceNotificationRule"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_c68f38e2b2b061c40209e85bf2"`,
+    );
+    await queryRunner.query(`DROP TABLE "WorkspaceSetting"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_73f5887268b09c0abccf04ef02"`,
+    );
+    await queryRunner.query(`DROP TABLE "WorkspaceProjectAuthToken"`);
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_4b7c7d1a8b2259df8c790db094"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_bee888f5782b9585e01f13455f"`,
+    );
+    await queryRunner.query(`DROP TABLE "WorkspaceUserAuthToken"`);
+  }
+}

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

@@ -0,0 +1,19 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1739210586538 implements MigrationInterface {
+  public name = "MigrationName1739210586538";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "Alert" ADD "alertNumber" integer`);
+    await queryRunner.query(
+      `CREATE INDEX "IDX_aa91b2228a2b35424a3ae93fdc" ON "Alert" ("alertNumber") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_aa91b2228a2b35424a3ae93fdc"`,
+    );
+    await queryRunner.query(`ALTER TABLE "Alert" DROP COLUMN "alertNumber"`);
+  }
+}

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

@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1739217257089 implements MigrationInterface {
+  public name = "MigrationName1739217257089";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" ADD "scheduledMaintenanceNumber" integer`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_207fe82fd8bdc67bbe1aa0ebf8" ON "ScheduledMaintenance" ("scheduledMaintenanceNumber") `,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_207fe82fd8bdc67bbe1aa0ebf8"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "ScheduledMaintenance" DROP COLUMN "scheduledMaintenanceNumber"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -99,6 +99,9 @@ import { MigrationName1737141420441 } from "./1737141420441-MigrationName";
 import { MigrationName1737713529424 } from "./1737713529424-MigrationName";
 import { MigrationName1737715240684 } from "./1737715240684-MigrationName";
 import { MigrationName1737997557974 } from "./1737997557974-MigrationName";
+import { MigrationName1739209832500 } from "./1739209832500-MigrationName";
+import { MigrationName1739210586538 } from "./1739210586538-MigrationName";
+import { MigrationName1739217257089 } from "./1739217257089-MigrationName";
 
 export default [
   InitialMigration,
@@ -202,4 +205,7 @@ export default [
   MigrationName1737713529424,
   MigrationName1737715240684,
   MigrationName1737997557974,
+  MigrationName1739209832500,
+  MigrationName1739210586538,
+  MigrationName1739217257089,
 ];

package/Server/Middleware/SlackAuthorization.ts

@@ -0,0 +1,60 @@
+import {
+  ExpressResponse,
+  NextFunction,
+  OneUptimeRequest,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BadDataException from "Common/Types/Exception/BadDataException";
+import { SlackAppSigningSecret } from "../EnvironmentConfig";
+import crypto from "crypto";
+import logger from "../Utils/Logger";
+
+export default class SlackAuthorization {
+  public static async isAuthorizedSlackRequest(
+    req: OneUptimeRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> {
+    if (!SlackAppSigningSecret) {
+      return Response.sendErrorResponse(
+        req,
+        res,
+        new BadDataException(
+          "SLACK_APP_SIGNING_SECRET env variable not found.",
+        ),
+      );
+    }
+
+    // validate slack signing secret
+    const slackSigningSecret: string = SlackAppSigningSecret.toString();
+
+    const slackSignature: string = req.headers["x-slack-signature"] as string;
+    const timestamp: string = req.headers[
+      "x-slack-request-timestamp"
+    ] as string;
+    const requestBody: string = req.body;
+
+    logger.debug(`slackSignature: ${slackSignature}`);
+    logger.debug(`timestamp: ${timestamp}`);
+    logger.debug(`requestBody: ${requestBody}`);
+
+    const baseString: string = `v0:${timestamp}:${requestBody}`;
+    const signature: string = `v0=${crypto.createHmac("sha256", slackSigningSecret).update(baseString).digest("hex")}`;
+
+    // check if the signature is valid
+    if (
+      !crypto.timingSafeEqual(
+        Buffer.from(signature),
+        Buffer.from(slackSignature),
+      )
+    ) {
+      return Response.sendErrorResponse(
+        req,
+        res,
+        new BadDataException("Slack Signature Verification Failed."),
+      );
+    }
+
+    next();
+  }
+}

package/Server/Services/AlertService.ts

@@ -98,6 +98,32 @@ export class Service extends DatabaseService<Model> {
     return false;
   }
 
+  public async getExistingAlertNumberForProject(data: {
+    projectId: ObjectID;
+  }): Promise<number> {
+    // get last alert number.
+    const lastAlert: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+      },
+      select: {
+        alertNumber: true,
+      },
+      sort: {
+        createdAt: SortOrder.Descending,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!lastAlert) {
+      return 0;
+    }
+
+    return lastAlert.alertNumber || 0;
+  }
+
   public async acknowledgeAlert(
     alertId: ObjectID,
     acknowledgedByUserId: ObjectID,
@@ -156,9 +182,12 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("ProjectId required to create alert.");
     }
 
+    const projectId: ObjectID =
+      createBy.props.tenantId || createBy.data.projectId!;
+
     const alertState: AlertState | null = await AlertStateService.findOneBy({
       query: {
-        projectId: createBy.props.tenantId || createBy.data.projectId!,
+        projectId: projectId,
         isCreatedState: true,
       },
       select: {
@@ -177,6 +206,13 @@ export class Service extends DatabaseService<Model> {
 
     createBy.data.currentAlertStateId = alertState.id;
 
+    const alertNumberForThisAlert: number =
+      (await this.getExistingAlertNumberForProject({
+        projectId: projectId,
+      })) + 1;
+
+    createBy.data.alertNumber = alertNumberForThisAlert;
+
     if (
       (createBy.data.createdByUserId ||
         createBy.data.createdByUser ||
@@ -239,7 +275,7 @@ export class Service extends DatabaseService<Model> {
       projectId: createdItem.projectId!,
       alertFeedEventType: AlertFeedEventType.AlertCreated,
       displayColor: Red500,
-      feedInfoInMarkdown: `**Alert Created**: 
+      feedInfoInMarkdown: `**Alert #${createdItem.alertNumber?.toString()} Created**:
           
   **Alert Title**:
   

package/Server/Services/Index.ts

@@ -152,6 +152,10 @@ import AlertFeedService from "./AlertFeedService";
 import IncidentFeedService from "./IncidentFeedService";
 
 import MonitorTestService from "./MonitorTestService";
+import WorkspaceProjectAuthTokenService from "./WorkspaceProjectAuthTokenService";
+import WorkspaceUserAuthTokenService from "./WorkspaceUserAuthTokenService";
+import WorkspaceSettingService from "./WorkspaceSettingService";
+import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
 
 const services: Array<BaseService> = [
   AcmeCertificateService,
@@ -317,6 +321,11 @@ const services: Array<BaseService> = [
 
   TableViewService,
   MonitorTestService,
+
+  WorkspaceProjectAuthTokenService,
+  WorkspaceUserAuthTokenService,
+  WorkspaceSettingService,
+  WorkspaceNotificationRuleService,
 ];
 
 export const AnalyticsServices: Array<

package/Server/Services/ProjectService.ts

@@ -67,7 +67,7 @@ import AlertSeverity from "../../Models/DatabaseModels/AlertSeverity";
 import AlertSeverityService from "./AlertSeverityService";
 import AlertState from "../../Models/DatabaseModels/AlertState";
 import AlertStateService from "./AlertStateService";
-import SlackUtil from "../Utils/Slack";
+import SlackUtil from "../Utils/Slack/Slack";
 import URL from "../../Types/API/URL";
 import Exception from "../../Types/Exception/Exception";
 
@@ -104,6 +104,8 @@ export class ProjectService extends DatabaseService<Model> {
       );
     }
 
+    logger.debug("Creating project for user " + data.props.userId);
+
     const user: User | null = await UserService.findOneById({
       id: data.props.userId,
       select: {

package/Server/Services/ScheduledMaintenanceService.ts

@@ -61,6 +61,32 @@ export class Service extends DatabaseService<Model> {
     }
   }
 
+  public async getExistingScheduledMaintenanceNumberForProject(data: {
+    projectId: ObjectID;
+  }): Promise<number> {
+    // get last scheduledMaintenance number.
+    const lastScheduledMaintenance: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+      },
+      select: {
+        scheduledMaintenanceNumber: true,
+      },
+      sort: {
+        createdAt: SortOrder.Descending,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!lastScheduledMaintenance) {
+      return 0;
+    }
+
+    return lastScheduledMaintenance.scheduledMaintenanceNumber || 0;
+  }
+
   public async notififySubscribersOnEventScheduled(
     scheduledEvents: Array<Model>,
   ): Promise<void> {
@@ -395,10 +421,13 @@ export class Service extends DatabaseService<Model> {
       );
     }
 
+    const projectId: ObjectID =
+      createBy.props.tenantId || createBy.data.projectId!;
+
     const scheduledMaintenanceState: ScheduledMaintenanceState | null =
       await ScheduledMaintenanceStateService.findOneBy({
         query: {
-          projectId: createBy.props.tenantId,
+          projectId: projectId,
           isScheduledState: true,
         },
         select: {
@@ -418,6 +447,14 @@ export class Service extends DatabaseService<Model> {
     createBy.data.currentScheduledMaintenanceStateId =
       scheduledMaintenanceState.id;
 
+    const scheduledMaintenanceNumberForThisScheduledMaintenance: number =
+      (await this.getExistingScheduledMaintenanceNumberForProject({
+        projectId: projectId,
+      })) + 1;
+
+    createBy.data.scheduledMaintenanceNumber =
+      scheduledMaintenanceNumberForThisScheduledMaintenance;
+
     // get next notification date.
 
     if (
@@ -455,7 +492,7 @@ export class Service extends DatabaseService<Model> {
       scheduledMaintenanceFeedEventType:
         ScheduledMaintenanceFeedEventType.ScheduledMaintenanceCreated,
       displayColor: Red500,
-      feedInfoInMarkdown: `**Scheduled Maintenance Created**: 
+      feedInfoInMarkdown: `**Scheduled Maintenance #${createdItem.scheduledMaintenanceNumber?.toString()} Created**: 
           
 **Scheduled Maintenance Title**:
 

package/Server/Services/UserService.ts

@@ -28,7 +28,7 @@ import Text from "../../Types/Text";
 import EmailVerificationToken from "Common/Models/DatabaseModels/EmailVerificationToken";
 import TeamMember from "Common/Models/DatabaseModels/TeamMember";
 import Model from "Common/Models/DatabaseModels/User";
-import SlackUtil from "../Utils/Slack";
+import SlackUtil from "../Utils/Slack/Slack";
 import UserTwoFactorAuth from "Common/Models/DatabaseModels/UserTwoFactorAuth";
 import UserTwoFactorAuthService from "./UserTwoFactorAuthService";
 import BadDataException from "../../Types/Exception/BadDataException";

package/Server/Services/WorkspaceNotificationRuleService.ts

@@ -0,0 +1,22 @@
+import NotificationRuleEventType from "../../Types/Workspace/NotificationRules/EventType";
+import { WorkspaceNotificationPayload } from "../../Types/Workspace/WorkspaceNotificationPayload";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import logger from "../Utils/Logger";
+import DatabaseService from "./DatabaseService";
+import Model from "Common/Models/DatabaseModels/WorkspaceNotificationRule";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async notifyWorkspace(data: {
+    workspaceType: WorkspaceType;
+    notificationRuleEventType: NotificationRuleEventType;
+    workspaceNotificationPayload: WorkspaceNotificationPayload;
+  }): Promise<void> {
+    logger.debug("Notify Workspace");
+    logger.debug(data);
+  }
+}
+export default new Service();

package/Server/Services/WorkspaceProjectAuthTokenService.ts

@@ -0,0 +1,84 @@
+import ObjectID from "../../Types/ObjectID";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import DatabaseService from "./DatabaseService";
+import Model, {
+  SlackMiscData,
+} from "Common/Models/DatabaseModels/WorkspaceProjectAuthToken";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async doesExist(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+  }): Promise<boolean> {
+    return (
+      (
+        await this.countBy({
+          query: {
+            projectId: data.projectId,
+            workspaceType: data.workspaceType,
+          },
+          skip: 0,
+          limit: 1,
+          props: {
+            isRoot: true,
+          },
+        })
+      ).toNumber() > 0
+    );
+  }
+
+  public async refreshAuthToken(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+    authToken: string;
+    workspaceProjectId: string;
+    miscData: SlackMiscData;
+  }): Promise<void> {
+    let projectAuth: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        workspaceType: data.workspaceType,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!projectAuth) {
+      projectAuth = new Model();
+
+      projectAuth.projectId = data.projectId;
+      projectAuth.authToken = data.authToken;
+      projectAuth.workspaceType = data.workspaceType;
+      projectAuth.workspaceProjectId = data.workspaceProjectId;
+      projectAuth.miscData = data.miscData;
+
+      await this.create({
+        data: projectAuth,
+        props: {
+          isRoot: true,
+        },
+      });
+    } else {
+      await this.updateOneById({
+        id: projectAuth.id!,
+        data: {
+          authToken: data.authToken,
+          workspaceProjectId: data.workspaceProjectId,
+          miscData: data.miscData,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+}
+export default new Service();

package/Server/Services/WorkspaceSettingService.ts

@@ -0,0 +1,78 @@
+import ObjectID from "../../Types/ObjectID";
+import WorkspaceType from "../../Types/Workspace/WorkspaceType";
+import DatabaseService from "./DatabaseService";
+import Model, {
+  SlackSettings,
+} from "Common/Models/DatabaseModels/WorkspaceSetting";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  public async doesExist(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+  }): Promise<boolean> {
+    return (
+      (
+        await this.countBy({
+          query: {
+            projectId: data.projectId,
+            workspaceType: data.workspaceType,
+          },
+          skip: 0,
+          limit: 1,
+          props: {
+            isRoot: true,
+          },
+        })
+      ).toNumber() > 0
+    );
+  }
+
+  public async refreshSetting(data: {
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+    settings: SlackSettings;
+  }): Promise<void> {
+    let workspaceSetting: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+        workspaceType: data.workspaceType,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!workspaceSetting) {
+      workspaceSetting = new Model();
+
+      workspaceSetting.projectId = data.projectId;
+      workspaceSetting.settings = data.settings;
+      workspaceSetting.workspaceType = data.workspaceType;
+
+      await this.create({
+        data: workspaceSetting,
+        props: {
+          isRoot: true,
+        },
+      });
+    } else {
+      await this.updateOneById({
+        id: workspaceSetting.id!,
+        data: {
+          settings: data.settings,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+    }
+  }
+}
+export default new Service();