@oneuptime/common 7.0.4003 → 7.0.4007

package/Server/Services/OnCallDutyPolicyScheduleService.ts

@@ -18,12 +18,158 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
-  @CaptureSpan()
-  public async getCurrentUserIdInSchedule(
+  public async getOnCallSchedulesWhereUserIsOnCallDuty(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+  }): Promise<Array<Model>> {
+    const schedules: Array<Model> = await this.findBy({
+      query: {
+        projectId: data.projectId,
+        currentUserIdOnRoster: data.userId,
+      },
+      select: {
+        _id: true,
+        name: true,
+      },
+      limit: LIMIT_PER_PROJECT,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return schedules;
+  }
+
+  public async refreshCurrentUserIdAndHandoffTimeInSchedule(
     scheduleId: ObjectID,
-  ): Promise<ObjectID | null> {
+  ): Promise<{
+    currentUserId: ObjectID | null;
+    handOffTimeAt: Date | null;
+    nextUserId: ObjectID | null;
+    nextHandOffTimeAt: Date | null;
+  }> {
+    const result: {
+      currentUserId: ObjectID | null;
+      handOffTimeAt: Date | null;
+      nextUserId: ObjectID | null;
+      nextHandOffTimeAt: Date | null;
+      rosterStartAt: Date | null;
+      nextRosterStartAt: Date | null;
+    } = await this.getCurrrentUserIdAndHandoffTimeInSchedule(scheduleId);
+
+    await this.updateOneById({
+      id: scheduleId!,
+      data: {
+        currentUserIdOnRoster: result.currentUserId,
+        rosterHandoffAt: result.handOffTimeAt,
+        nextUserIdOnRoster: result.nextUserId,
+        rosterNextHandoffAt: result.nextHandOffTimeAt,
+        rosterStartAt: result.rosterStartAt,
+        rosterNextStartAt: result.nextRosterStartAt,
+      },
+      props: {
+        isRoot: true,
+        ignoreHooks: true,
+      },
+    });
+
+    return result;
+  }
+
+  public async getCurrrentUserIdAndHandoffTimeInSchedule(
+    scheduleId: ObjectID,
+  ): Promise<{
+    rosterStartAt: Date | null;
+    currentUserId: ObjectID | null;
+    handOffTimeAt: Date | null;
+    nextUserId: ObjectID | null;
+    nextHandOffTimeAt: Date | null;
+    nextRosterStartAt: Date | null;
+  }> {
+    const resultReturn: {
+      rosterStartAt: Date | null;
+      currentUserId: ObjectID | null;
+      handOffTimeAt: Date | null;
+      nextUserId: ObjectID | null;
+      nextHandOffTimeAt: Date | null;
+      nextRosterStartAt: Date | null;
+    } = {
+      currentUserId: null,
+      handOffTimeAt: null,
+      nextUserId: null,
+      nextHandOffTimeAt: null,
+      rosterStartAt: null,
+      nextRosterStartAt: null,
+    };
+
+    const events: Array<CalendarEvent> | null =
+      await this.getEventByIndexInSchedule({
+        scheduleId: scheduleId,
+        getNumberOfEvents: 2,
+      });
+
+    let currentEvent: CalendarEvent | null = events[0] || null;
+    let nextEvent: CalendarEvent | null = events[1] || null;
+
+    // if the current event start time in the future then the current event is the next event.
+    if (currentEvent && OneUptimeDate.isInTheFuture(currentEvent.start)) {
+      nextEvent = currentEvent;
+      currentEvent = null;
+    }
+
+    if (currentEvent) {
+      const userId: string | undefined = currentEvent?.title; // this is user id in string.
+
+      if (userId) {
+        resultReturn.currentUserId = new ObjectID(userId);
+      }
+
+      // get handOffTime
+      const handOffTime: Date | undefined = currentEvent?.end; // this is user id in string.
+      if (handOffTime) {
+        resultReturn.handOffTimeAt = handOffTime;
+      }
+
+      // get start time
+      const startTime: Date | undefined = currentEvent?.start; // this is user id in string.
+      if (startTime) {
+        resultReturn.rosterStartAt = startTime;
+      }
+    }
+
+    // do the same for next event.
+
+    if (nextEvent) {
+      const userId: string | undefined = nextEvent?.title; // this is user id in string.
+
+      if (userId) {
+        resultReturn.nextUserId = new ObjectID(userId);
+      }
+
+      // get handOffTime
+      const handOffTime: Date | undefined = nextEvent?.end; // this is user id in string.
+      if (handOffTime) {
+        resultReturn.nextHandOffTimeAt = handOffTime;
+      }
+
+      // get start time
+      const startTime: Date | undefined = nextEvent?.start; // this is user id in string.
+      if (startTime) {
+        resultReturn.nextRosterStartAt = startTime;
+      }
+    }
+
+    return resultReturn;
+  }
+
+  private async getScheduleLayerProps(data: {
+    scheduleId: ObjectID;
+  }): Promise<Array<LayerProps>> {
     // get schedule layers.
 
+    const scheduleId: ObjectID = data.scheduleId;
+
     const layers: Array<OnCallDutyPolicyScheduleLayer> =
       await OnCallDutyPolicyScheduleLayerService.findBy({
         query: {
@@ -70,12 +216,6 @@ export class Service extends DatabaseService<Model> {
         },
       });
 
-    const currentStartTime: Date = OneUptimeDate.getCurrentDate();
-    const currentEndTime: Date = OneUptimeDate.addRemoveSeconds(
-      currentStartTime,
-      1,
-    );
-
     const layerProps: Array<LayerProps> = [];
 
     for (const layer of layers) {
@@ -101,17 +241,78 @@ export class Service extends DatabaseService<Model> {
       });
     }
 
-    const events: Array<CalendarEvent> = LayerUtil.getMultiLayerEvents({
-      layers: layerProps,
-      calendarStartDate: currentStartTime,
-      calendarEndDate: currentEndTime,
+    return layerProps;
+  }
+
+  public async getEventByIndexInSchedule(data: {
+    scheduleId: ObjectID;
+    getNumberOfEvents: number; // which event would you like to get. First event, second event, etc.
+  }): Promise<Array<CalendarEvent>> {
+    const layerProps: Array<LayerProps> = await this.getScheduleLayerProps({
+      scheduleId: data.scheduleId,
     });
 
-    if (events.length === 0) {
+    if (layerProps.length === 0) {
+      return [];
+    }
+
+    const currentStartTime: Date = OneUptimeDate.getCurrentDate();
+    const currentEndTime: Date = OneUptimeDate.addRemoveYears(
+      currentStartTime,
+      1,
+    );
+
+    const numberOfEventsToGet: number = data.getNumberOfEvents;
+    const events: Array<CalendarEvent> = LayerUtil.getMultiLayerEvents(
+      {
+        layers: layerProps,
+        calendarStartDate: currentStartTime,
+        calendarEndDate: currentEndTime,
+      },
+      {
+        getNumberOfEvents: numberOfEventsToGet,
+      },
+    );
+
+    return events;
+  }
+
+  @CaptureSpan()
+  public async getCurrentUserIdInSchedule(
+    scheduleId: ObjectID,
+  ): Promise<ObjectID | null> {
+    const layerProps: Array<LayerProps> = await this.getScheduleLayerProps({
+      scheduleId: scheduleId,
+    });
+
+    if (layerProps.length === 0) {
+      return null;
+    }
+
+    const currentStartTime: Date = OneUptimeDate.getCurrentDate();
+    const currentEndTime: Date = OneUptimeDate.addRemoveSeconds(
+      currentStartTime,
+      1,
+    );
+
+    const events: Array<CalendarEvent> = LayerUtil.getMultiLayerEvents(
+      {
+        layers: layerProps,
+        calendarStartDate: currentStartTime,
+        calendarEndDate: currentEndTime,
+      },
+      {
+        getNumberOfEvents: 1,
+      },
+    );
+
+    const currentEvent: CalendarEvent | null = events[0] || null;
+
+    if (!currentEvent) {
       return null;
     }
 
-    const userId: string | undefined = events[0]?.title; // this is user id in string.
+    const userId: string | undefined = currentEvent?.title; // this is user id in string.
 
     if (!userId) {
       return null;

package/Server/Services/OnCallDutyPolicyService.ts

@@ -9,6 +9,18 @@ import OnCallDutyPolicyExecutionLog from "Common/Models/DatabaseModels/OnCallDut
 import DatabaseConfig from "../DatabaseConfig";
 import URL from "../../Types/API/URL";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import OnCallDutyPolicySchedule from "../../Models/DatabaseModels/OnCallDutyPolicySchedule";
+import OnCallDutyPolicyScheduleService from "./OnCallDutyPolicyScheduleService";
+import TeamService from "./TeamService";
+import Team from "../../Models/DatabaseModels/Team";
+import OnCallDutyPolicyEscalationRuleUser from "../../Models/DatabaseModels/OnCallDutyPolicyEscalationRuleUser";
+import OnCallDutyPolicyEscalationRuleUserService from "./OnCallDutyPolicyEscalationRuleUserService";
+import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
+import OnCallDutyPolicyEscalationRuleTeam from "../../Models/DatabaseModels/OnCallDutyPolicyEscalationRuleTeam";
+import OnCallDutyPolicyEscalationRuleTeamService from "./OnCallDutyPolicyEscalationRuleTeamService";
+import QueryHelper from "../Types/Database/QueryHelper";
+import OnCallDutyPolicyEscalationRuleSchedule from "../../Models/DatabaseModels/OnCallDutyPolicyEscalationRuleSchedule";
+import OnCallDutyPolicyEscalationRuleScheduleService from "./OnCallDutyPolicyEscalationRuleScheduleService";
 
 export class Service extends DatabaseService<OnCallDutyPolicy> {
   public constructor() {
@@ -100,5 +112,122 @@ export class Service extends DatabaseService<OnCallDutyPolicy> {
       },
     });
   }
+
+  public async getOnCallPoliciesWhereUserIsOnCallDuty(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+  }): Promise<{
+    escalationRulesByUser: Array<OnCallDutyPolicyEscalationRuleUser>;
+    escalationRulesByTeam: Array<OnCallDutyPolicyEscalationRuleTeam>;
+    escalationRulesBySchedule: Array<OnCallDutyPolicyEscalationRuleSchedule>;
+  }> {
+    // get all schedules where user is on call duty.
+    const onCallSchedules: Array<OnCallDutyPolicySchedule> =
+      await OnCallDutyPolicyScheduleService.getOnCallSchedulesWhereUserIsOnCallDuty(
+        data,
+      );
+
+    const teams: Array<Team> = await TeamService.getTeamsUserIsAPartOf({
+      userId: data.userId,
+      projectId: data.projectId,
+    });
+
+    // get escalationPolicies by user, team and schedule.
+    const escalationRulesByUser: Array<OnCallDutyPolicyEscalationRuleUser> =
+      await OnCallDutyPolicyEscalationRuleUserService.findBy({
+        query: {
+          userId: data.userId!,
+          projectId: data.projectId!,
+        },
+        select: {
+          onCallDutyPolicyEscalationRule: {
+            name: true,
+            _id: true,
+            order: true,
+          },
+          onCallDutyPolicy: {
+            name: true,
+            _id: true,
+          },
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    // do the same for teams.
+    const escalationRulesByTeam: Array<OnCallDutyPolicyEscalationRuleTeam> =
+      await OnCallDutyPolicyEscalationRuleTeamService.findBy({
+        query: {
+          teamId: QueryHelper.any(
+            teams.map((team: Team) => {
+              return team.id!;
+            }),
+          ),
+          projectId: data.projectId!,
+        },
+        select: {
+          onCallDutyPolicy: {
+            name: true,
+            _id: true,
+          },
+          onCallDutyPolicyEscalationRule: {
+            name: true,
+            _id: true,
+            order: true,
+          },
+          team: {
+            name: true,
+            _id: true,
+          },
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    // do the same for schedules.
+    const escalationRulesBySchedule: Array<OnCallDutyPolicyEscalationRuleSchedule> =
+      await OnCallDutyPolicyEscalationRuleScheduleService.findBy({
+        query: {
+          onCallDutyPolicyScheduleId: QueryHelper.any(
+            onCallSchedules.map((schedule: OnCallDutyPolicySchedule) => {
+              return schedule.id!;
+            }),
+          ),
+          projectId: data.projectId!,
+        },
+        select: {
+          onCallDutyPolicy: {
+            name: true,
+            _id: true,
+          },
+          onCallDutyPolicyEscalationRule: {
+            name: true,
+            _id: true,
+            order: true,
+          },
+          onCallDutyPolicySchedule: {
+            name: true,
+            _id: true,
+          },
+        },
+        limit: LIMIT_PER_PROJECT,
+        skip: 0,
+        props: {
+          isRoot: true,
+        },
+      });
+
+    return {
+      escalationRulesByUser: escalationRulesByUser,
+      escalationRulesByTeam: escalationRulesByTeam,
+      escalationRulesBySchedule: escalationRulesBySchedule,
+    };
+  }
 }
 export default new Service();

package/Server/Services/TeamService.ts

@@ -6,12 +6,48 @@ import LIMIT_MAX from "../../Types/Database/LimitMax";
 import BadDataException from "../../Types/Exception/BadDataException";
 import Model from "Common/Models/DatabaseModels/Team";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ObjectID from "../../Types/ObjectID";
+import TeamMember from "../../Models/DatabaseModels/TeamMember";
+import TeamMemberService from "./TeamMemberService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
 
+  public async getTeamsUserIsAPartOf(data: {
+    userId: ObjectID;
+    projectId: ObjectID;
+  }): Promise<Array<Model>> {
+    const teamMembers: Array<TeamMember> = await TeamMemberService.findBy({
+      query: {
+        userId: data.userId,
+        projectId: data.projectId,
+      },
+      select: {
+        team: {
+          name: true,
+          _id: true,
+        },
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const teams: Array<Model> = [];
+
+    for (const teamMember of teamMembers) {
+      if (teamMember.team) {
+        teams.push(teamMember.team);
+      }
+    }
+
+    return teams;
+  }
+
   @CaptureSpan()
   protected override async onBeforeUpdate(
     updateBy: UpdateBy<Model>,

package/Types/Date.ts

@@ -14,6 +14,16 @@ export default class OneUptimeDate {
     return new Date(timestamp * 1000);
   }
 
+  public static getStartOfTheWeek(date: Date): Date {
+    date = this.fromString(date);
+    return moment(date).startOf("week").toDate();
+  }
+
+  public static getEndOfTheWeek(date: Date): Date {
+    date = this.fromString(date);
+    return moment(date).endOf("week").toDate();
+  }
+
   public static getInBetweenDatesAsFormattedString(
     inBetween: InBetween<Date>,
   ): string {
@@ -104,6 +114,11 @@ export default class OneUptimeDate {
     return this.addRemoveDays(date, difference);
   }
 
+  public static getDayOfTheWeekIndex(date: Date): number {
+    date = this.fromString(date);
+    return moment(date).weekday();
+  }
+
   public static isOverlapping(
     start: Date,
     end: Date,
@@ -765,13 +780,13 @@ export default class OneUptimeDate {
   public static isAfter(date: Date, startDate: Date): boolean {
     date = this.fromString(date);
     startDate = this.fromString(startDate);
-    return moment(date).isAfter(startDate);
+    return moment(date).isAfter(startDate, "seconds");
   }
 
   public static isOnOrAfter(date: Date, startDate: Date): boolean {
     date = this.fromString(date);
     startDate = this.fromString(startDate);
-    return moment(date).isSameOrAfter(startDate);
+    return moment(date).isSameOrAfter(startDate, "seconds");
   }
 
   public static getDayOfWeek(date: Date): DayOfWeek {
@@ -804,7 +819,8 @@ export default class OneUptimeDate {
   public static isOnOrBefore(date: Date, endDate: Date): boolean {
     date = this.fromString(date);
     endDate = this.fromString(endDate);
-    return moment(date).isSameOrBefore(endDate);
+
+    return moment(date).isSameOrBefore(endDate, "seconds");
   }
 
   public static isEqualBySeconds(date: Date, startDate: Date): boolean {
@@ -815,13 +831,13 @@ export default class OneUptimeDate {
 
   public static hasExpired(expirationDate: Date): boolean {
     expirationDate = this.fromString(expirationDate);
-    return !moment(this.getCurrentDate()).isBefore(expirationDate);
+    return !moment(this.getCurrentDate()).isBefore(expirationDate, "seconds");
   }
 
   public static isBefore(date: Date, endDate: Date): boolean {
     date = this.fromString(date);
     endDate = this.fromString(endDate);
-    return moment(date).isBefore(endDate);
+    return moment(date).isBefore(endDate, "seconds");
   }
 
   public static getCurrentDateAsFormattedString(options?: {
@@ -1135,12 +1151,12 @@ export default class OneUptimeDate {
 
   public static isInThePast(date: string | Date): boolean {
     date = this.fromString(date);
-    return moment(date).isBefore(new Date());
+    return moment(date).isBefore(new Date(), "seconds");
   }
 
   public static isInTheFuture(date: string | Date): boolean {
     date = this.fromString(date);
-    return moment(date).isAfter(new Date());
+    return moment(date).isAfter(new Date(), "seconds");
   }
 
   public static fromString(date: string | JSONObject | Date): Date {