@oneuptime/common 7.0.4003 → 7.0.4007

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/OnCallDutyPolicyScheduleLayerService.ts

@@ -1,6 +1,6 @@
 import CreateBy from "../Types/Database/CreateBy";
 import DeleteBy from "../Types/Database/DeleteBy";
-import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
 import QueryHelper from "../Types/Database/QueryHelper";
 import DatabaseService from "./DatabaseService";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
@@ -10,6 +10,7 @@ import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import Model from "Common/Models/DatabaseModels/OnCallDutyPolicyScheduleLayer";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import OnCallDutyPolicyScheduleService from "./OnCallDutyPolicyScheduleService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -51,6 +52,61 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const resource: Model | null = await this.findOneById({
+      id: createdItem.id!,
+      select: {
+        onCallDutyPolicyScheduleId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!resource || !resource.onCallDutyPolicyScheduleId) {
+      return createdItem;
+    }
+
+    await OnCallDutyPolicyScheduleService.refreshCurrentUserIdAndHandoffTimeInSchedule(
+      resource.onCallDutyPolicyScheduleId,
+    );
+
+    return createdItem;
+  }
+
+  protected override async onUpdateSuccess(
+    _onUpdate: OnUpdate<Model>,
+    updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    for (const item of updatedItemIds) {
+      const resource: Model | null = await this.findOneById({
+        id: item,
+        select: {
+          onCallDutyPolicyScheduleId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!resource || !resource.onCallDutyPolicyScheduleId) {
+        continue;
+      }
+
+      await OnCallDutyPolicyScheduleService.refreshCurrentUserIdAndHandoffTimeInSchedule(
+        resource.onCallDutyPolicyScheduleId,
+      );
+    }
+
+    return {
+      updateBy: _onUpdate.updateBy,
+      carryForward: null,
+    };
+  }
+
   @CaptureSpan()
   protected override async onDeleteSuccess(
     onDelete: OnDelete<Model>,
@@ -66,6 +122,10 @@ export class Service extends DatabaseService<Model> {
           resource.onCallDutyPolicyScheduleId,
           false,
         );
+
+        await OnCallDutyPolicyScheduleService.refreshCurrentUserIdAndHandoffTimeInSchedule(
+          resource.onCallDutyPolicyScheduleId,
+        );
       }
     }
 

package/Server/Services/OnCallDutyPolicyScheduleLayerUserService.ts

@@ -11,6 +11,7 @@ import ObjectID from "../../Types/ObjectID";
 import PositiveNumber from "../../Types/PositiveNumber";
 import Model from "Common/Models/DatabaseModels/OnCallDutyPolicyScheduleLayerUser";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import OnCallDutyPolicyScheduleService from "./OnCallDutyPolicyScheduleService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -79,6 +80,12 @@ export class Service extends DatabaseService<Model> {
           resource.onCallDutyPolicyScheduleLayerId,
           false,
         );
+
+        if (resource.onCallDutyPolicyScheduleId) {
+          await OnCallDutyPolicyScheduleService.refreshCurrentUserIdAndHandoffTimeInSchedule(
+            resource.onCallDutyPolicyScheduleId,
+          );
+        }
       }
     }
 
@@ -109,6 +116,7 @@ export class Service extends DatabaseService<Model> {
         select: {
           order: true,
           onCallDutyPolicyScheduleLayerId: true,
+          onCallDutyPolicyScheduleId: true,
         },
       });
     }
@@ -119,6 +127,61 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  protected override async onCreateSuccess(
+    _onCreate: OnCreate<Model>,
+    createdItem: Model,
+  ): Promise<Model> {
+    const resource: Model | null = await this.findOneById({
+      id: createdItem.id!,
+      select: {
+        onCallDutyPolicyScheduleId: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!resource || !resource.onCallDutyPolicyScheduleId) {
+      return createdItem;
+    }
+
+    await OnCallDutyPolicyScheduleService.refreshCurrentUserIdAndHandoffTimeInSchedule(
+      resource.onCallDutyPolicyScheduleId,
+    );
+
+    return createdItem;
+  }
+
+  protected override async onUpdateSuccess(
+    _onUpdate: OnUpdate<Model>,
+    updatedItemIds: Array<ObjectID>,
+  ): Promise<OnUpdate<Model>> {
+    for (const item of updatedItemIds) {
+      const resource: Model | null = await this.findOneById({
+        id: item,
+        select: {
+          onCallDutyPolicyScheduleId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!resource || !resource.onCallDutyPolicyScheduleId) {
+        continue;
+      }
+
+      await OnCallDutyPolicyScheduleService.refreshCurrentUserIdAndHandoffTimeInSchedule(
+        resource.onCallDutyPolicyScheduleId,
+      );
+    }
+
+    return {
+      updateBy: _onUpdate.updateBy,
+      carryForward: null,
+    };
+  }
+
   @CaptureSpan()
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,