@oneuptime/common 7.0.4006 → 7.0.4019

package/Models/DatabaseModels/OnCallDutyPolicySchedule.ts

@@ -517,6 +517,28 @@ export default class OnCallDutyPolicySchedule extends BaseModel {
   })
   public nextUserIdOnRoster?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectOnCallDutyPolicySchedule,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Date,
+    title: "Roster Handoff At",
+    description:
+      "When does the roster handoff occur for this schedule for the current user?",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public rosterHandoffAt?: Date = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [
@@ -530,11 +552,56 @@ export default class OnCallDutyPolicySchedule extends BaseModel {
   @TableColumn({
     type: TableColumnType.Date,
     title: "Roster Next Handoff At",
-    description: "When is the next roster handoff for this schedule?",
+    description:
+      "When does the next roster handoff occur for this schedule for the next user?",
   })
   @Column({
     type: ColumnType.Date,
     nullable: true,
   })
   public rosterNextHandoffAt?: Date = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectOnCallDutyPolicySchedule,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Date,
+    title: "Roster Next Event Start At",
+    description:
+      "When does the next event start for this schedule for the next user?",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public rosterNextStartAt?: Date = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectOnCallDutyPolicySchedule,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Date,
+    title: "Roster Event Start At",
+    description:
+      "When does the current event start for this schedule for the current user?",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public rosterStartAt?: Date = undefined;
 }

package/Models/DatabaseModels/OnCallDutyPolicyScheduleLayer.ts

@@ -552,83 +552,4 @@ export default class OnCallDutyPolicyScheduleLayer extends BaseModel {
     transformer: RestrictionTimes.getDatabaseTransformer(),
   })
   public restrictionTimes?: RestrictionTimes = undefined;
-
-  @ColumnAccessControl({
-    create: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.ProjectMember,
-      Permission.CreateProjectOnCallDutyPolicySchedule,
-    ],
-    read: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.ProjectMember,
-      Permission.ReadProjectOnCallDutyPolicySchedule,
-    ],
-    update: [],
-  })
-  @TableColumn({
-    manyToOneRelationColumn: "nextUserIdOnLayer",
-    type: TableColumnType.Entity,
-    modelType: User,
-    title: "Next User On Layer",
-    description: "Relation to User who is next on layer",
-  })
-  @ManyToOne(
-    () => {
-      return User;
-    },
-    {
-      eager: false,
-      nullable: true,
-      onDelete: "SET NULL",
-      orphanedRowAction: "nullify",
-    },
-  )
-  @JoinColumn({ name: "nextUserIdOnLayer" })
-  public nextUserOnLayer?: User = undefined;
-
-  @ColumnAccessControl({
-    create: [],
-    read: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.ProjectMember,
-      Permission.ReadProjectOnCallDutyPolicySchedule,
-    ],
-    update: [],
-  })
-  @TableColumn({
-    type: TableColumnType.ObjectID,
-    title: "Next User ID On Layer",
-    description: "Next ID who is currently on layer",
-  })
-  @Column({
-    type: ColumnType.ObjectID,
-    nullable: true,
-    transformer: ObjectID.getDatabaseTransformer(),
-  })
-  public nextUserIdOnLayer?: ObjectID = undefined;
-
-  @ColumnAccessControl({
-    create: [],
-    read: [
-      Permission.ProjectOwner,
-      Permission.ProjectAdmin,
-      Permission.ProjectMember,
-      Permission.ReadProjectOnCallDutyPolicySchedule,
-    ],
-    update: [],
-  })
-  @TableColumn({
-    type: TableColumnType.Date,
-    title: "Layer Next Handoff At",
-    description: "When is the next layer handoff for this schedule?",
-  })
-  @Column({
-    type: ColumnType.Date,
-    nullable: true,
-  })
-  public layerNextHandoffAt?: Date = undefined;
 }

package/Server/API/OnCallDutyPolicyAPI.ts

@@ -0,0 +1,87 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import OnCallDutyPolicyService, {
+  Service as OnCallDutyPolicyServiceType,
+} from "../Services/OnCallDutyPolicyService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import CommonAPI from "./CommonAPI";
+import DatabaseCommonInteractionProps from "Common/Types/BaseDatabase/DatabaseCommonInteractionProps";
+import BadDataException from "Common/Types/Exception/BadDataException";
+import ObjectID from "Common/Types/ObjectID";
+import OnCallDutyPolicy from "Common/Models/DatabaseModels/OnCallDutyPolicy";
+import OnCallDutyPolicyEscalationRuleUser from "../../Models/DatabaseModels/OnCallDutyPolicyEscalationRuleUser";
+import OnCallDutyPolicyEscalationRuleTeam from "../../Models/DatabaseModels/OnCallDutyPolicyEscalationRuleTeam";
+import OnCallDutyPolicyEscalationRuleSchedule from "../../Models/DatabaseModels/OnCallDutyPolicyEscalationRuleSchedule";
+import BaseModel from "Common/Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+
+export default class OnCallDutyPolicyAPI extends BaseAPI<
+  OnCallDutyPolicy,
+  OnCallDutyPolicyServiceType
+> {
+  public constructor() {
+    super(OnCallDutyPolicy, OnCallDutyPolicyService);
+
+    // CNAME verification api. THis API will be used from the dashboard to validate the CNAME MANUALLY.
+    this.router.get(
+      `${new this.entityType().getCrudApiPath()?.toString()}/current-on-duty-escalation-policies`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const databaseProps: DatabaseCommonInteractionProps =
+            await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+          const projectId: ObjectID = databaseProps.tenantId as ObjectID;
+
+          const userId: ObjectID = databaseProps.userId as ObjectID;
+
+          if (!projectId) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid projectId."),
+            );
+          }
+
+          if (!userId) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid userId."),
+            );
+          }
+
+          const result: {
+            escalationRulesByUser: Array<OnCallDutyPolicyEscalationRuleUser>;
+            escalationRulesByTeam: Array<OnCallDutyPolicyEscalationRuleTeam>;
+            escalationRulesBySchedule: Array<OnCallDutyPolicyEscalationRuleSchedule>;
+          } = await this.service.getOnCallPoliciesWhereUserIsOnCallDuty({
+            projectId: projectId,
+            userId: userId,
+          });
+
+          return Response.sendJsonObjectResponse(req, res, {
+            escalationRulesByUser: BaseModel.toJSONArray(
+              result.escalationRulesByUser,
+              OnCallDutyPolicyEscalationRuleUser,
+            ),
+            escalationRulesByTeam: BaseModel.toJSONArray(
+              result.escalationRulesByTeam,
+              OnCallDutyPolicyEscalationRuleTeam,
+            ),
+            escalationRulesBySchedule: BaseModel.toJSONArray(
+              result.escalationRulesBySchedule,
+              OnCallDutyPolicyEscalationRuleSchedule,
+            ),
+          });
+        } catch (e) {
+          next(e);
+        }
+      },
+    );
+  }
+}

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

@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1743692467814 implements MigrationInterface {
+  public name = "MigrationName1743692467814";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" DROP CONSTRAINT "FK_815023b155d367f28cc6855b843"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" DROP COLUMN "nextUserIdOnLayer"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" DROP COLUMN "layerNextHandoffAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicySchedule" ADD "rosterHandoffAt" TIMESTAMP WITH TIME ZONE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicySchedule" DROP COLUMN "rosterHandoffAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ADD "layerNextHandoffAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ADD "nextUserIdOnLayer" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicyScheduleLayer" ADD CONSTRAINT "FK_815023b155d367f28cc6855b843" FOREIGN KEY ("nextUserIdOnLayer") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+  }
+}

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

@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class MigrationName1743714801105 implements MigrationInterface {
+  public name = "MigrationName1743714801105";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicySchedule" ADD "rosterNextStartAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicySchedule" ADD "rosterStartAt" TIMESTAMP WITH TIME ZONE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicySchedule" DROP COLUMN "rosterStartAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "OnCallDutyPolicySchedule" DROP COLUMN "rosterNextStartAt"`,
+    );
+  }
+}

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

@@ -127,6 +127,8 @@ import { MigrationName1743518485566 } from "./1743518485566-MigrationName";
 import { MigrationName1743521461137 } from "./1743521461137-MigrationName";
 import { MigrationName1743530326936 } from "./1743530326936-MigrationName";
 import { MigrationName1743538648415 } from "./1743538648415-MigrationName";
+import { MigrationName1743692467814 } from "./1743692467814-MigrationName";
+import { MigrationName1743714801105 } from "./1743714801105-MigrationName";
 
 export default [
   InitialMigration,
@@ -258,4 +260,6 @@ export default [
   MigrationName1743521461137,
   MigrationName1743530326936,
   MigrationName1743538648415,
+  MigrationName1743692467814,
+  MigrationName1743714801105,
 ];

package/Server/Services/OnCallDutyPolicyEscalationRuleScheduleService.ts

@@ -1,10 +1,253 @@
+import BadDataException from "../../Types/Exception/BadDataException";
+import ObjectID from "../../Types/ObjectID";
+import { OnCreate, OnDelete } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "Common/Models/DatabaseModels/OnCallDutyPolicyEscalationRuleSchedule";
+import Dictionary from "../../Types/Dictionary";
+import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
+import EmailTemplateType from "../../Types/Email/EmailTemplateType";
+import { EmailEnvelope } from "../../Types/Email/EmailMessage";
+import { SMSMessage } from "../../Types/SMS/SMS";
+import UserNotificationSettingService from "./UserNotificationSettingService";
+import NotificationSettingEventType from "../../Types/NotificationSetting/NotificationSettingEventType";
+import { CallRequestMessage } from "../../Types/Call/CallRequest";
+import DeleteBy from "../Types/Database/DeleteBy";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import OnCallDutyPolicyScheduleService from "./OnCallDutyPolicyScheduleService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const createdItemId: ObjectID = createdItem.id!;
+
+    if (!createdItemId) {
+      throw new BadDataException("Created item does not have an ID");
+    }
+
+    const createdModel: Model | null = await this.findOneById({
+      id: createdItemId,
+      select: {
+        projectId: true,
+        onCallDutyPolicyScheduleId: true,
+        onCallDutyPolicySchedule: {
+          name: true,
+        },
+        onCallDutyPolicyEscalationRule: {
+          name: true,
+          _id: true,
+          order: true,
+        },
+        onCallDutyPolicy: {
+          name: true,
+          _id: true,
+        },
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!createdModel) {
+      throw new BadDataException("Created item does not have an ID");
+    }
+
+    if (!createdModel.onCallDutyPolicyScheduleId) {
+      throw new BadDataException(
+        "Created item does not have a onCallDutyPolicyScheduleId",
+      );
+    }
+
+    // send notification to the new current user.
+
+    const userOnSchedule: ObjectID | null =
+      await OnCallDutyPolicyScheduleService.getCurrentUserIdInSchedule(
+        createdModel.onCallDutyPolicyScheduleId,
+      );
+
+    if (!userOnSchedule) {
+      return createdItem;
+    }
+
+    const scheduleName: string =
+      createdModel.onCallDutyPolicySchedule?.name || "No name provided";
+
+    const sendEmailToUserId: ObjectID | undefined | null = userOnSchedule;
+
+    if (!sendEmailToUserId) {
+      return createdItem;
+    }
+
+    if (!createdModel) {
+      return createdItem;
+    }
+
+    const vars: Dictionary<string> = {
+      onCallPolicyName:
+        createdModel.onCallDutyPolicy?.name || "No name provided",
+      escalationRuleName:
+        createdModel.onCallDutyPolicyEscalationRule?.name || "No name provided",
+      escalationRuleOrder:
+        createdModel.onCallDutyPolicyEscalationRule?.order?.toString() ||
+        "No order provided",
+      reason: "You are currently on roster for schedule " + scheduleName,
+      onCallPolicyViewLink: (
+        await OnCallDutyPolicyService.getOnCallPolicyLinkInDashboard(
+          createdModel!.projectId!,
+          createdModel.onCallDutyPolicy!.id!,
+        )
+      ).toString(),
+    };
+
+    // Notify the current user about being added to the schedule.
+    const emailMessage: EmailEnvelope = {
+      templateType: EmailTemplateType.UserAddedToOnCallPolicy,
+      vars: vars,
+      subject: `You have been added to the on-call duty policy ${createdModel.onCallDutyPolicy?.name} for schedule ${scheduleName}`,
+    };
+
+    const sms: SMSMessage = {
+      message: `This is a message from OneUptime. You have been added to the on-call duty policy ${createdModel.onCallDutyPolicy?.name} for schedule ${scheduleName} and escalation rule ${createdModel.onCallDutyPolicyEscalationRule?.name} with order ${createdModel.onCallDutyPolicyEscalationRule?.order}. To unsubscribe from this notification, go to User Settings in the OneUptime Dashboard.`,
+    };
+
+    const callMessage: CallRequestMessage = {
+      data: [
+        {
+          sayMessage: `This is a message from OneUptime. You have been added to the on-call duty policy ${createdModel.onCallDutyPolicy?.name} for schedule ${scheduleName} and escalation rule ${createdModel.onCallDutyPolicyEscalationRule?.name} with order ${createdModel.onCallDutyPolicyEscalationRule?.order}. To unsubscribe from this notification, go to User Settings in the OneUptime Dashboard. Goodbye.`,
+        },
+      ],
+    };
+
+    await UserNotificationSettingService.sendUserNotification({
+      userId: sendEmailToUserId,
+      projectId: createdModel!.projectId!,
+      emailEnvelope: emailMessage,
+      smsMessage: sms,
+      callRequestMessage: callMessage,
+      eventType:
+        NotificationSettingEventType.SEND_WHEN_USER_IS_ADDED_TO_ON_CALL_POLICY,
+    });
+
+    return createdItem;
+  }
+
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const itemsToFetchBeforeDelete: Array<Model> = await this.findBy({
+      query: deleteBy.query,
+      props: {
+        isRoot: true,
+      },
+      select: {
+        projectId: true,
+        onCallDutyPolicyScheduleId: true,
+        onCallDutyPolicySchedule: {
+          name: true,
+          _id: true,
+        },
+        onCallDutyPolicyEscalationRule: {
+          name: true,
+          _id: true,
+          order: true,
+        },
+        onCallDutyPolicy: {
+          name: true,
+          _id: true,
+        },
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+    });
+
+    return {
+      deleteBy,
+      carryForward: {
+        deletedItems: itemsToFetchBeforeDelete,
+      },
+    };
+  }
+
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    _itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deletedItems: Array<Model> = onDelete.carryForward.deletedItems;
+
+    for (const deletedItem of deletedItems) {
+      const userOnSchedule: ObjectID | null =
+        await OnCallDutyPolicyScheduleService.getCurrentUserIdInSchedule(
+          deletedItem.onCallDutyPolicyScheduleId!,
+        );
+
+      if (!userOnSchedule) {
+        continue;
+      }
+
+      const sendEmailToUserId: ObjectID | undefined | null = userOnSchedule;
+
+      if (!sendEmailToUserId) {
+        return onDelete;
+      }
+
+      const scheduleName: string =
+        deletedItem.onCallDutyPolicySchedule?.name || "No name provided";
+
+      const vars: Dictionary<string> = {
+        onCallPolicyName:
+          deletedItem.onCallDutyPolicy?.name || "No name provided",
+        escalationRuleName:
+          deletedItem.onCallDutyPolicyEscalationRule?.name ||
+          "No name provided",
+        escalationRuleOrder:
+          deletedItem.onCallDutyPolicyEscalationRule?.order?.toString() ||
+          "No order provided",
+        reason: `You have been removed from the on-call duty policy escalation rule for schedule ${scheduleName}.`,
+        onCallPolicyViewLink: (
+          await OnCallDutyPolicyService.getOnCallPolicyLinkInDashboard(
+            deletedItem!.projectId!,
+            deletedItem.onCallDutyPolicy!.id!,
+          )
+        ).toString(),
+      };
+
+      // Notify the current user about being removed from the schedule.
+      const emailMessage: EmailEnvelope = {
+        templateType: EmailTemplateType.UserRemovedFromOnCallPolicy,
+        vars: vars,
+        subject: `You have been removed from the on-call duty policy ${deletedItem.onCallDutyPolicy?.name} for schedule ${scheduleName}`,
+      };
+
+      const sms: SMSMessage = {
+        message: `This is a message from OneUptime. You have been removed from the on-call duty policy ${deletedItem.onCallDutyPolicy?.name} for schedule ${scheduleName} and escalation rule ${deletedItem.onCallDutyPolicyEscalationRule?.name} with order ${deletedItem.onCallDutyPolicyEscalationRule?.order}. To unsubscribe from this notification go to User Settings in OneUptime Dashboard.`,
+      };
+
+      const callMessage: CallRequestMessage = {
+        data: [
+          {
+            sayMessage: `This is a message from OneUptime. You have been removed from the on-call duty policy ${deletedItem.onCallDutyPolicy?.name} for schedule ${scheduleName} and escalation rule ${deletedItem.onCallDutyPolicyEscalationRule?.name} with order ${deletedItem.onCallDutyPolicyEscalationRule?.order}. To unsubscribe from this notification go to User Settings in OneUptime Dashboard. Good Bye`,
+          },
+        ],
+      };
+
+      await UserNotificationSettingService.sendUserNotification({
+        userId: sendEmailToUserId,
+        projectId: deletedItem!.projectId!,
+        emailEnvelope: emailMessage,
+        smsMessage: sms,
+        callRequestMessage: callMessage,
+        eventType:
+          NotificationSettingEventType.SEND_WHEN_USER_IS_REMOVED_FROM_ON_CALL_POLICY,
+      });
+    }
+
+    return onDelete;
+  }
 }
 
 export default new Service();

package/Server/Services/OnCallDutyPolicyEscalationRuleService.ts

@@ -671,6 +671,52 @@ export class Service extends DatabaseService<Model> {
         select: {
           order: true,
           onCallDutyPolicyId: true,
+          projectId: true,
+        },
+      });
+
+      if (!resource) {
+        throw new BadDataException(
+          "OnCallDutyPolicyEscalationRule with this id not found",
+        );
+      }
+
+      // delete users in escalation rule, teams in escalation rule and schedules in escalation rule.
+      await OnCallDutyPolicyEscalationRuleScheduleService.deleteBy({
+        query: {
+          onCallDutyPolicyEscalationRuleId: resource.id!,
+          projectId: resource.projectId!,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      // delete users in escalation rule.
+      await OnCallDutyPolicyEscalationRuleUserService.deleteBy({
+        query: {
+          onCallDutyPolicyEscalationRuleId: resource.id!,
+          projectId: resource.projectId!,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+      // delete teams in escalation rule.
+      await OnCallDutyPolicyEscalationRuleTeamService.deleteBy({
+        query: {
+          onCallDutyPolicyEscalationRuleId: resource.id!,
+          projectId: resource.projectId!,
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
         },
       });
     }