@oneuptime/common 7.0.2513 → 7.0.2550

package/Types/OnCallDutyPolicy/Layer.ts

@@ -1,1018 +1,976 @@
-import UserModel from '../../Models/UserModel';
-import CalendarEvent from '../Calendar/CalendarEvent';
-import OneUptimeDate from '../Date';
-import DayOfWeek from '../Day/DayOfWeek';
-import EventInterval from '../Events/EventInterval';
-import Recurring from '../Events/Recurring';
-import StartAndEndTime from '../Time/StartAndEndTime';
-import Typeof from '../Typeof';
+import UserModel from "../../Models/UserModel";
+import CalendarEvent from "../Calendar/CalendarEvent";
+import OneUptimeDate from "../Date";
+import DayOfWeek from "../Day/DayOfWeek";
+import EventInterval from "../Events/EventInterval";
+import Recurring from "../Events/Recurring";
+import StartAndEndTime from "../Time/StartAndEndTime";
+import Typeof from "../Typeof";
 import RestrictionTimes, {
-    RestrictionType,
-    WeeklyResctriction,
-} from './RestrictionTimes';
+  RestrictionType,
+  WeeklyResctriction,
+} from "./RestrictionTimes";
 
 export interface LayerProps {
-    users: Array<UserModel>;
-    startDateTimeOfLayer: Date;
-    restrictionTimes: RestrictionTimes;
-    handOffTime: Date;
-    rotation: Recurring;
+  users: Array<UserModel>;
+  startDateTimeOfLayer: Date;
+  restrictionTimes: RestrictionTimes;
+  handOffTime: Date;
+  rotation: Recurring;
 }
 
 export interface EventProps extends LayerProps {
-    calendarStartDate: Date;
-    calendarEndDate: Date;
+  calendarStartDate: Date;
+  calendarEndDate: Date;
 }
 
 export interface MultiLayerProps {
-    layers: Array<LayerProps>;
-    calendarStartDate: Date;
-    calendarEndDate: Date;
+  layers: Array<LayerProps>;
+  calendarStartDate: Date;
+  calendarEndDate: Date;
 }
 
 export interface PriorityCalendarEvents extends CalendarEvent {
-    priority: number;
+  priority: number;
 }
 
 export default class LayerUtil {
-    public static getEvents(data: EventProps): Array<CalendarEvent> {
-        let events: Array<CalendarEvent> = [];
+  public static getEvents(data: EventProps): Array<CalendarEvent> {
+    let events: Array<CalendarEvent> = [];
 
-        if (!LayerUtil.isDataValid(data)) {
-            return [];
-        }
+    if (!LayerUtil.isDataValid(data)) {
+      return [];
+    }
 
-        data = LayerUtil.sanitizeData(data);
+    data = LayerUtil.sanitizeData(data);
 
-        let start: Date = data.calendarStartDate;
-        const end: Date = data.calendarEndDate;
+    let start: Date = data.calendarStartDate;
+    const end: Date = data.calendarEndDate;
 
-        // start time of the layer is after the start time of the calendar, so we need to update the start time of the calendar
-        if (OneUptimeDate.isAfter(data.startDateTimeOfLayer, start)) {
-            start = data.startDateTimeOfLayer;
-        }
+    // start time of the layer is after the start time of the calendar, so we need to update the start time of the calendar
+    if (OneUptimeDate.isAfter(data.startDateTimeOfLayer, start)) {
+      start = data.startDateTimeOfLayer;
+    }
 
-        // split events by rotation.
+    // split events by rotation.
 
-        const rotation: Recurring = data.rotation;
+    const rotation: Recurring = data.rotation;
 
-        let hasReachedTheEndOfTheCalendar: boolean = false;
+    let hasReachedTheEndOfTheCalendar: boolean = false;
 
-        let handOffTime: Date = data.handOffTime;
+    let handOffTime: Date = data.handOffTime;
 
-        if (!handOffTime) {
-            return [];
-        }
+    if (!handOffTime) {
+      return [];
+    }
 
-        // Looop vars
-        let currentUserIndex: number = 0;
-        let currentEventStartTime: Date = start;
+    // Looop vars
+    let currentUserIndex: number = 0;
+    let currentEventStartTime: Date = start;
 
-        // bring handoff time to the same day as the currentStartTime.
+    // bring handoff time to the same day as the currentStartTime.
 
-        // before we do this, we need to update the user index.
+    // before we do this, we need to update the user index.
 
-        currentUserIndex = LayerUtil.getCurrentUserIndexBasedOnHandoffTime({
-            rotation,
-            handOffTime,
-            currentUserIndex,
-            startDateTimeOfLayer: data.startDateTimeOfLayer,
-            users: data.users,
-            currentEventStartTime,
-        });
+    currentUserIndex = LayerUtil.getCurrentUserIndexBasedOnHandoffTime({
+      rotation,
+      handOffTime,
+      currentUserIndex,
+      startDateTimeOfLayer: data.startDateTimeOfLayer,
+      users: data.users,
+      currentEventStartTime,
+    });
 
-        // update handoff time to the same day as current start time
+    // update handoff time to the same day as current start time
 
-        handOffTime = LayerUtil.moveHandsOffTimeAfterCurrentEventStartTime({
-            handOffTime,
-            currentEventStartTime,
-            rotation: data.rotation,
+    handOffTime = LayerUtil.moveHandsOffTimeAfterCurrentEventStartTime({
+      handOffTime,
+      currentEventStartTime,
+      rotation: data.rotation,
+    });
+
+    let currentEventEndTime: Date = OneUptimeDate.getCurrentDate(); // temporary set to current time to avoid typescript error
+
+    // check if calendar end is before the handoff time. if it is, then we need to return the event with the current user index as no handoff is needed.
+
+    if (OneUptimeDate.isBefore(end, handOffTime)) {
+      const trimmedStartAndEndTimes: Array<StartAndEndTime> =
+        LayerUtil.trimStartAndEndTimesBasedOnRestrictionTimes({
+          eventStartTime: currentEventStartTime,
+          eventEndTime: end,
+          restrictionTimes: data.restrictionTimes,
         });
 
-        let currentEventEndTime: Date = OneUptimeDate.getCurrentDate(); // temporary set to current time to avoid typescript error
+      events = [
+        ...events,
+        ...LayerUtil.getCalendarEventsFromStartAndEndDates(
+          trimmedStartAndEndTimes,
+          data.users,
+          currentUserIndex,
+        ),
+      ];
 
-        // check if calendar end is before the handoff time. if it is, then we need to return the event with the current user index as no handoff is needed.
+      return events;
+    }
 
-        if (OneUptimeDate.isBefore(end, handOffTime)) {
-            const trimmedStartAndEndTimes: Array<StartAndEndTime> =
-                LayerUtil.trimStartAndEndTimesBasedOnRestrictionTimes({
-                    eventStartTime: currentEventStartTime,
-                    eventEndTime: end,
-                    restrictionTimes: data.restrictionTimes,
-                });
+    while (!hasReachedTheEndOfTheCalendar) {
+      currentEventEndTime = handOffTime;
 
-            events = [
-                ...events,
-                ...LayerUtil.getCalendarEventsFromStartAndEndDates(
-                    trimmedStartAndEndTimes,
-                    data.users,
-                    currentUserIndex
-                ),
-            ];
+      // if current event start time and end time is the same then increase current event start time by 1 second.
 
-            return events;
-        }
+      if (OneUptimeDate.isSame(currentEventStartTime, currentEventEndTime)) {
+        currentEventStartTime = OneUptimeDate.addRemoveSeconds(
+          currentEventEndTime,
+          1,
+        );
+        handOffTime = LayerUtil.moveHandsOffTimeAfterCurrentEventStartTime({
+          handOffTime,
+          currentEventStartTime,
+          rotation: data.rotation,
+        });
 
-        while (!hasReachedTheEndOfTheCalendar) {
-            currentEventEndTime = handOffTime;
-
-            // if current event start time and end time is the same then increase current event start time by 1 second.
-
-            if (
-                OneUptimeDate.isSame(currentEventStartTime, currentEventEndTime)
-            ) {
-                currentEventStartTime = OneUptimeDate.addRemoveSeconds(
-                    currentEventEndTime,
-                    1
-                );
-                handOffTime =
-                    LayerUtil.moveHandsOffTimeAfterCurrentEventStartTime({
-                        handOffTime,
-                        currentEventStartTime,
-                        rotation: data.rotation,
-                    });
-
-                continue;
-            }
+        continue;
+      }
 
-            // check calendar end time. if the end time of the event is after the end time of the calendar, we need to update the end time of the event
-            if (OneUptimeDate.isAfter(currentEventEndTime, end)) {
-                currentEventEndTime = end;
-                hasReachedTheEndOfTheCalendar = true;
-            }
+      // check calendar end time. if the end time of the event is after the end time of the calendar, we need to update the end time of the event
+      if (OneUptimeDate.isAfter(currentEventEndTime, end)) {
+        currentEventEndTime = end;
+        hasReachedTheEndOfTheCalendar = true;
+      }
 
-            // check restriction times. if the end time of the event is after the end time of the restriction times, we need to update the end time of the event.
-
-            const trimmedStartAndEndTimes: Array<StartAndEndTime> =
-                LayerUtil.trimStartAndEndTimesBasedOnRestrictionTimes({
-                    eventStartTime: currentEventStartTime,
-                    eventEndTime: currentEventEndTime,
-                    restrictionTimes: data.restrictionTimes,
-                });
-
-            events = [
-                ...events,
-                ...LayerUtil.getCalendarEventsFromStartAndEndDates(
-                    trimmedStartAndEndTimes,
-                    data.users,
-                    currentUserIndex
-                ),
-            ];
-
-            // update the current event start time
-
-            currentEventStartTime = OneUptimeDate.addRemoveSeconds(
-                currentEventEndTime,
-                1
-            );
-
-            // update the handoff time
-
-            handOffTime = LayerUtil.moveHandsOffTimeAfterCurrentEventStartTime({
-                handOffTime,
-                currentEventStartTime,
-                rotation: data.rotation,
-            });
-
-            // update the current user index
-            currentUserIndex = LayerUtil.incrementUserIndex(
-                currentUserIndex,
-                data.users.length
-            );
-        }
+      // check restriction times. if the end time of the event is after the end time of the restriction times, we need to update the end time of the event.
+
+      const trimmedStartAndEndTimes: Array<StartAndEndTime> =
+        LayerUtil.trimStartAndEndTimesBasedOnRestrictionTimes({
+          eventStartTime: currentEventStartTime,
+          eventEndTime: currentEventEndTime,
+          restrictionTimes: data.restrictionTimes,
+        });
 
-        // increment ids of all the events and return them, to make sure they are unique
+      events = [
+        ...events,
+        ...LayerUtil.getCalendarEventsFromStartAndEndDates(
+          trimmedStartAndEndTimes,
+          data.users,
+          currentUserIndex,
+        ),
+      ];
+
+      // update the current event start time
+
+      currentEventStartTime = OneUptimeDate.addRemoveSeconds(
+        currentEventEndTime,
+        1,
+      );
+
+      // update the handoff time
+
+      handOffTime = LayerUtil.moveHandsOffTimeAfterCurrentEventStartTime({
+        handOffTime,
+        currentEventStartTime,
+        rotation: data.rotation,
+      });
+
+      // update the current user index
+      currentUserIndex = LayerUtil.incrementUserIndex(
+        currentUserIndex,
+        data.users.length,
+      );
+    }
 
-        let id: number = 1;
+    // increment ids of all the events and return them, to make sure they are unique
 
-        for (const event of events) {
-            event.id = id;
-            id++;
-        }
+    let id: number = 1;
 
-        return events;
+    for (const event of events) {
+      event.id = id;
+      id++;
     }
 
-    private static sanitizeData(data: EventProps): EventProps {
-        if (!(data.restrictionTimes instanceof RestrictionTimes)) {
-            data.restrictionTimes = RestrictionTimes.fromJSON(
-                data.restrictionTimes
-            );
-        }
+    return events;
+  }
 
-        if (!(data.rotation instanceof Recurring)) {
-            data.rotation = Recurring.fromJSON(data.rotation);
-        }
+  private static sanitizeData(data: EventProps): EventProps {
+    if (!(data.restrictionTimes instanceof RestrictionTimes)) {
+      data.restrictionTimes = RestrictionTimes.fromJSON(data.restrictionTimes);
+    }
 
-        if (typeof data.startDateTimeOfLayer === Typeof.String) {
-            data.startDateTimeOfLayer = OneUptimeDate.fromString(
-                data.startDateTimeOfLayer
-            );
-        }
+    if (!(data.rotation instanceof Recurring)) {
+      data.rotation = Recurring.fromJSON(data.rotation);
+    }
 
-        if (typeof data.calendarStartDate === Typeof.String) {
-            data.calendarStartDate = OneUptimeDate.fromString(
-                data.calendarStartDate
-            );
-        }
+    if (typeof data.startDateTimeOfLayer === Typeof.String) {
+      data.startDateTimeOfLayer = OneUptimeDate.fromString(
+        data.startDateTimeOfLayer,
+      );
+    }
 
-        if (typeof data.calendarEndDate === Typeof.String) {
-            data.calendarEndDate = OneUptimeDate.fromString(
-                data.calendarEndDate
-            );
-        }
+    if (typeof data.calendarStartDate === Typeof.String) {
+      data.calendarStartDate = OneUptimeDate.fromString(data.calendarStartDate);
+    }
 
-        if (typeof data.handOffTime === Typeof.String) {
-            data.handOffTime = OneUptimeDate.fromString(data.handOffTime);
-        }
+    if (typeof data.calendarEndDate === Typeof.String) {
+      data.calendarEndDate = OneUptimeDate.fromString(data.calendarEndDate);
+    }
 
-        return data;
+    if (typeof data.handOffTime === Typeof.String) {
+      data.handOffTime = OneUptimeDate.fromString(data.handOffTime);
     }
 
-    private static isDataValid(data: EventProps): boolean {
-        // if calendar end time is before the start time then return an empty array.
-        if (
-            OneUptimeDate.isBefore(data.calendarEndDate, data.calendarStartDate)
-        ) {
-            return false;
-        }
+    return data;
+  }
 
-        // end time of the layer is before the end time of the calendar, so, we dont have any events and we can return empty array
-        if (
-            OneUptimeDate.isAfter(
-                data.startDateTimeOfLayer,
-                data.calendarEndDate
-            )
-        ) {
-            return false;
-        }
+  private static isDataValid(data: EventProps): boolean {
+    // if calendar end time is before the start time then return an empty array.
+    if (OneUptimeDate.isBefore(data.calendarEndDate, data.calendarStartDate)) {
+      return false;
+    }
 
-        // if users are empty, we dont have any events and we can return empty array
-        if (data.users.length === 0) {
-            return false;
-        }
+    // end time of the layer is before the end time of the calendar, so, we dont have any events and we can return empty array
+    if (
+      OneUptimeDate.isAfter(data.startDateTimeOfLayer, data.calendarEndDate)
+    ) {
+      return false;
+    }
 
-        return true;
+    // if users are empty, we dont have any events and we can return empty array
+    if (data.users.length === 0) {
+      return false;
     }
 
-    private static moveHandsOffTimeAfterCurrentEventStartTime(data: {
-        handOffTime: Date;
-        currentEventStartTime: Date;
-        rotation: Recurring;
-    }): Date {
-        // if handoff time is ahead of the current event start time, then we dont need to move and we can return it as is.
+    return true;
+  }
 
-        if (
-            OneUptimeDate.isAfter(data.handOffTime, data.currentEventStartTime)
-        ) {
-            return data.handOffTime;
-        }
+  private static moveHandsOffTimeAfterCurrentEventStartTime(data: {
+    handOffTime: Date;
+    currentEventStartTime: Date;
+    rotation: Recurring;
+  }): Date {
+    // if handoff time is ahead of the current event start time, then we dont need to move and we can return it as is.
 
-        let handOffTime: Date = data.handOffTime;
-
-        let intervalBetweenStartTimeAndHandoffTime: number = 0;
-        const rotationInterval: number = data.rotation.intervalCount.toNumber();
-
-        if (data.rotation.intervalType === EventInterval.Day) {
-            intervalBetweenStartTimeAndHandoffTime =
-                OneUptimeDate.getDaysBetweenTwoDatesInclusive(
-                    handOffTime,
-                    data.currentEventStartTime
-                );
-
-            if (intervalBetweenStartTimeAndHandoffTime < rotationInterval) {
-                intervalBetweenStartTimeAndHandoffTime = rotationInterval;
-            } else if (
-                intervalBetweenStartTimeAndHandoffTime % rotationInterval !==
-                0
-            ) {
-                intervalBetweenStartTimeAndHandoffTime += rotationInterval;
-            }
+    if (OneUptimeDate.isAfter(data.handOffTime, data.currentEventStartTime)) {
+      return data.handOffTime;
+    }
 
-            // add intervalBetweenStartTimeAndHandoffTime to handoff time
+    let handOffTime: Date = data.handOffTime;
 
-            handOffTime = OneUptimeDate.addRemoveDays(
-                handOffTime,
-                intervalBetweenStartTimeAndHandoffTime
-            );
+    let intervalBetweenStartTimeAndHandoffTime: number = 0;
+    const rotationInterval: number = data.rotation.intervalCount.toNumber();
 
-            return handOffTime;
-        }
+    if (data.rotation.intervalType === EventInterval.Day) {
+      intervalBetweenStartTimeAndHandoffTime =
+        OneUptimeDate.getDaysBetweenTwoDatesInclusive(
+          handOffTime,
+          data.currentEventStartTime,
+        );
 
-        if (data.rotation.intervalType === EventInterval.Hour) {
-            intervalBetweenStartTimeAndHandoffTime =
-                OneUptimeDate.getHoursBetweenTwoDatesInclusive(
-                    handOffTime,
-                    data.currentEventStartTime
-                );
-
-            if (intervalBetweenStartTimeAndHandoffTime < rotationInterval) {
-                intervalBetweenStartTimeAndHandoffTime = rotationInterval;
-            } else if (
-                intervalBetweenStartTimeAndHandoffTime % rotationInterval !==
-                0
-            ) {
-                intervalBetweenStartTimeAndHandoffTime += rotationInterval;
-            }
+      if (intervalBetweenStartTimeAndHandoffTime < rotationInterval) {
+        intervalBetweenStartTimeAndHandoffTime = rotationInterval;
+      } else if (
+        intervalBetweenStartTimeAndHandoffTime % rotationInterval !==
+        0
+      ) {
+        intervalBetweenStartTimeAndHandoffTime += rotationInterval;
+      }
 
-            // add intervalBetweenStartTimeAndHandoffTime to handoff time
+      // add intervalBetweenStartTimeAndHandoffTime to handoff time
 
-            handOffTime = OneUptimeDate.addRemoveHours(
-                handOffTime,
-                intervalBetweenStartTimeAndHandoffTime
-            );
+      handOffTime = OneUptimeDate.addRemoveDays(
+        handOffTime,
+        intervalBetweenStartTimeAndHandoffTime,
+      );
 
-            return handOffTime;
-        }
+      return handOffTime;
+    }
 
-        if (data.rotation.intervalType === EventInterval.Week) {
-            intervalBetweenStartTimeAndHandoffTime =
-                OneUptimeDate.getWeeksBetweenTwoDatesInclusive(
-                    handOffTime,
-                    data.currentEventStartTime
-                );
-
-            if (intervalBetweenStartTimeAndHandoffTime < rotationInterval) {
-                intervalBetweenStartTimeAndHandoffTime = rotationInterval;
-            } else if (
-                intervalBetweenStartTimeAndHandoffTime % rotationInterval !==
-                0
-            ) {
-                intervalBetweenStartTimeAndHandoffTime += rotationInterval;
-            }
+    if (data.rotation.intervalType === EventInterval.Hour) {
+      intervalBetweenStartTimeAndHandoffTime =
+        OneUptimeDate.getHoursBetweenTwoDatesInclusive(
+          handOffTime,
+          data.currentEventStartTime,
+        );
 
-            // add intervalBetweenStartTimeAndHandoffTime to handoff time
+      if (intervalBetweenStartTimeAndHandoffTime < rotationInterval) {
+        intervalBetweenStartTimeAndHandoffTime = rotationInterval;
+      } else if (
+        intervalBetweenStartTimeAndHandoffTime % rotationInterval !==
+        0
+      ) {
+        intervalBetweenStartTimeAndHandoffTime += rotationInterval;
+      }
 
-            handOffTime = OneUptimeDate.addRemoveWeeks(
-                handOffTime,
-                intervalBetweenStartTimeAndHandoffTime
-            );
+      // add intervalBetweenStartTimeAndHandoffTime to handoff time
 
-            return handOffTime;
-        }
+      handOffTime = OneUptimeDate.addRemoveHours(
+        handOffTime,
+        intervalBetweenStartTimeAndHandoffTime,
+      );
 
-        if (data.rotation.intervalType === EventInterval.Month) {
-            intervalBetweenStartTimeAndHandoffTime =
-                OneUptimeDate.getMonthsBetweenTwoDatesInclusive(
-                    handOffTime,
-                    data.currentEventStartTime
-                );
-
-            if (intervalBetweenStartTimeAndHandoffTime < rotationInterval) {
-                intervalBetweenStartTimeAndHandoffTime = rotationInterval;
-            } else if (
-                intervalBetweenStartTimeAndHandoffTime % rotationInterval !==
-                0
-            ) {
-                intervalBetweenStartTimeAndHandoffTime += rotationInterval;
-            }
+      return handOffTime;
+    }
 
-            // add intervalBetweenStartTimeAndHandoffTime to handoff time
+    if (data.rotation.intervalType === EventInterval.Week) {
+      intervalBetweenStartTimeAndHandoffTime =
+        OneUptimeDate.getWeeksBetweenTwoDatesInclusive(
+          handOffTime,
+          data.currentEventStartTime,
+        );
 
-            handOffTime = OneUptimeDate.addRemoveMonths(
-                handOffTime,
-                intervalBetweenStartTimeAndHandoffTime
-            );
+      if (intervalBetweenStartTimeAndHandoffTime < rotationInterval) {
+        intervalBetweenStartTimeAndHandoffTime = rotationInterval;
+      } else if (
+        intervalBetweenStartTimeAndHandoffTime % rotationInterval !==
+        0
+      ) {
+        intervalBetweenStartTimeAndHandoffTime += rotationInterval;
+      }
 
-            return handOffTime;
-        }
+      // add intervalBetweenStartTimeAndHandoffTime to handoff time
 
-        if (data.rotation.intervalType === EventInterval.Year) {
-            intervalBetweenStartTimeAndHandoffTime =
-                OneUptimeDate.getYearsBetweenTwoDatesInclusive(
-                    handOffTime,
-                    data.currentEventStartTime
-                );
-
-            if (intervalBetweenStartTimeAndHandoffTime < rotationInterval) {
-                intervalBetweenStartTimeAndHandoffTime = rotationInterval;
-            } else if (
-                intervalBetweenStartTimeAndHandoffTime % rotationInterval !==
-                0
-            ) {
-                intervalBetweenStartTimeAndHandoffTime += rotationInterval;
-            }
+      handOffTime = OneUptimeDate.addRemoveWeeks(
+        handOffTime,
+        intervalBetweenStartTimeAndHandoffTime,
+      );
+
+      return handOffTime;
+    }
 
-            // add intervalBetweenStartTimeAndHandoffTime to handoff time
+    if (data.rotation.intervalType === EventInterval.Month) {
+      intervalBetweenStartTimeAndHandoffTime =
+        OneUptimeDate.getMonthsBetweenTwoDatesInclusive(
+          handOffTime,
+          data.currentEventStartTime,
+        );
 
-            handOffTime = OneUptimeDate.addRemoveYears(
-                handOffTime,
-                intervalBetweenStartTimeAndHandoffTime
-            );
+      if (intervalBetweenStartTimeAndHandoffTime < rotationInterval) {
+        intervalBetweenStartTimeAndHandoffTime = rotationInterval;
+      } else if (
+        intervalBetweenStartTimeAndHandoffTime % rotationInterval !==
+        0
+      ) {
+        intervalBetweenStartTimeAndHandoffTime += rotationInterval;
+      }
 
-            return handOffTime;
-        }
+      // add intervalBetweenStartTimeAndHandoffTime to handoff time
 
-        return handOffTime;
+      handOffTime = OneUptimeDate.addRemoveMonths(
+        handOffTime,
+        intervalBetweenStartTimeAndHandoffTime,
+      );
+
+      return handOffTime;
     }
 
-    private static getCurrentUserIndexBasedOnHandoffTime(data: {
-        rotation: Recurring;
-        handOffTime: Date;
-        currentUserIndex: number;
-        startDateTimeOfLayer: Date;
-        users: Array<UserModel>;
-        currentEventStartTime: Date;
-    }): number {
-        let intervalBetweenStartTimeAndHandoffTime: number = 0;
-        const rotation: Recurring = data.rotation;
-        const handOffTime: Date = data.handOffTime;
-        let currentUserIndex: number = data.currentUserIndex;
+    if (data.rotation.intervalType === EventInterval.Year) {
+      intervalBetweenStartTimeAndHandoffTime =
+        OneUptimeDate.getYearsBetweenTwoDatesInclusive(
+          handOffTime,
+          data.currentEventStartTime,
+        );
 
-        // if current event start time if before the start time of the layer then return current Index
+      if (intervalBetweenStartTimeAndHandoffTime < rotationInterval) {
+        intervalBetweenStartTimeAndHandoffTime = rotationInterval;
+      } else if (
+        intervalBetweenStartTimeAndHandoffTime % rotationInterval !==
+        0
+      ) {
+        intervalBetweenStartTimeAndHandoffTime += rotationInterval;
+      }
 
-        if (
-            OneUptimeDate.isBefore(
-                data.currentEventStartTime,
-                data.startDateTimeOfLayer
-            )
-        ) {
-            return currentUserIndex;
-        }
+      // add intervalBetweenStartTimeAndHandoffTime to handoff time
 
-        // if handoff time is ahead of current event stat time then return current index
+      handOffTime = OneUptimeDate.addRemoveYears(
+        handOffTime,
+        intervalBetweenStartTimeAndHandoffTime,
+      );
 
-        if (OneUptimeDate.isAfter(handOffTime, data.currentEventStartTime)) {
-            return currentUserIndex;
-        }
+      return handOffTime;
+    }
 
-        if (rotation.intervalType === EventInterval.Day) {
-            // calculate the number of days between the start time of the layer and the handoff time.
-            intervalBetweenStartTimeAndHandoffTime =
-                OneUptimeDate.getDaysBetweenTwoDatesInclusive(
-                    handOffTime,
-                    data.currentEventStartTime
-                );
-        }
+    return handOffTime;
+  }
 
-        if (rotation.intervalType === EventInterval.Hour) {
-            // calculate the number of hours between the start time of the layer and the handoff time.
-            intervalBetweenStartTimeAndHandoffTime =
-                OneUptimeDate.getHoursBetweenTwoDatesInclusive(
-                    handOffTime,
-                    data.currentEventStartTime
-                );
-        }
+  private static getCurrentUserIndexBasedOnHandoffTime(data: {
+    rotation: Recurring;
+    handOffTime: Date;
+    currentUserIndex: number;
+    startDateTimeOfLayer: Date;
+    users: Array<UserModel>;
+    currentEventStartTime: Date;
+  }): number {
+    let intervalBetweenStartTimeAndHandoffTime: number = 0;
+    const rotation: Recurring = data.rotation;
+    const handOffTime: Date = data.handOffTime;
+    let currentUserIndex: number = data.currentUserIndex;
+
+    // if current event start time if before the start time of the layer then return current Index
+
+    if (
+      OneUptimeDate.isBefore(
+        data.currentEventStartTime,
+        data.startDateTimeOfLayer,
+      )
+    ) {
+      return currentUserIndex;
+    }
 
-        if (rotation.intervalType === EventInterval.Week) {
-            // calculate the number of weeks between the start time of the layer and the handoff time.
-            intervalBetweenStartTimeAndHandoffTime =
-                OneUptimeDate.getWeeksBetweenTwoDatesInclusive(
-                    handOffTime,
-                    data.currentEventStartTime
-                );
-        }
+    // if handoff time is ahead of current event stat time then return current index
 
-        if (rotation.intervalType === EventInterval.Month) {
-            // calculate the number of months between the start time of the layer and the handoff time.
-            intervalBetweenStartTimeAndHandoffTime =
-                OneUptimeDate.getMonthsBetweenTwoDatesInclusive(
-                    handOffTime,
-                    data.currentEventStartTime
-                );
-        }
+    if (OneUptimeDate.isAfter(handOffTime, data.currentEventStartTime)) {
+      return currentUserIndex;
+    }
 
-        if (rotation.intervalType === EventInterval.Year) {
-            // calculate the number of years between the start time of the layer and the handoff time.
-            intervalBetweenStartTimeAndHandoffTime =
-                OneUptimeDate.getYearsBetweenTwoDatesInclusive(
-                    data.startDateTimeOfLayer,
-                    handOffTime
-                );
-        }
+    if (rotation.intervalType === EventInterval.Day) {
+      // calculate the number of days between the start time of the layer and the handoff time.
+      intervalBetweenStartTimeAndHandoffTime =
+        OneUptimeDate.getDaysBetweenTwoDatesInclusive(
+          handOffTime,
+          data.currentEventStartTime,
+        );
+    }
 
-        // now divide the interval between start time and handoff time by the interval count.
+    if (rotation.intervalType === EventInterval.Hour) {
+      // calculate the number of hours between the start time of the layer and the handoff time.
+      intervalBetweenStartTimeAndHandoffTime =
+        OneUptimeDate.getHoursBetweenTwoDatesInclusive(
+          handOffTime,
+          data.currentEventStartTime,
+        );
+    }
 
-        let numberOfIntervalsBetweenStartAndHandoffTime: number = Math.ceil(
-            intervalBetweenStartTimeAndHandoffTime /
-                rotation.intervalCount.toNumber()
+    if (rotation.intervalType === EventInterval.Week) {
+      // calculate the number of weeks between the start time of the layer and the handoff time.
+      intervalBetweenStartTimeAndHandoffTime =
+        OneUptimeDate.getWeeksBetweenTwoDatesInclusive(
+          handOffTime,
+          data.currentEventStartTime,
         );
+    }
 
-        if (numberOfIntervalsBetweenStartAndHandoffTime < 0) {
-            numberOfIntervalsBetweenStartAndHandoffTime =
-                numberOfIntervalsBetweenStartAndHandoffTime * -1;
-        }
+    if (rotation.intervalType === EventInterval.Month) {
+      // calculate the number of months between the start time of the layer and the handoff time.
+      intervalBetweenStartTimeAndHandoffTime =
+        OneUptimeDate.getMonthsBetweenTwoDatesInclusive(
+          handOffTime,
+          data.currentEventStartTime,
+        );
+    }
 
-        currentUserIndex = LayerUtil.incrementUserIndex(
-            currentUserIndex,
-            data.users.length,
-            numberOfIntervalsBetweenStartAndHandoffTime
+    if (rotation.intervalType === EventInterval.Year) {
+      // calculate the number of years between the start time of the layer and the handoff time.
+      intervalBetweenStartTimeAndHandoffTime =
+        OneUptimeDate.getYearsBetweenTwoDatesInclusive(
+          data.startDateTimeOfLayer,
+          handOffTime,
         );
+    }
+
+    // now divide the interval between start time and handoff time by the interval count.
+
+    let numberOfIntervalsBetweenStartAndHandoffTime: number = Math.ceil(
+      intervalBetweenStartTimeAndHandoffTime /
+        rotation.intervalCount.toNumber(),
+    );
 
-        return currentUserIndex;
+    if (numberOfIntervalsBetweenStartAndHandoffTime < 0) {
+      numberOfIntervalsBetweenStartAndHandoffTime =
+        numberOfIntervalsBetweenStartAndHandoffTime * -1;
     }
 
-    public static trimStartAndEndTimesBasedOnRestrictionTimes(data: {
-        eventStartTime: Date;
-        eventEndTime: Date;
-        restrictionTimes: RestrictionTimes;
-    }): Array<StartAndEndTime> {
-        const restrictionTimes: RestrictionTimes = data.restrictionTimes;
+    currentUserIndex = LayerUtil.incrementUserIndex(
+      currentUserIndex,
+      data.users.length,
+      numberOfIntervalsBetweenStartAndHandoffTime,
+    );
 
-        if (restrictionTimes.restictionType === RestrictionType.None) {
-            return [
-                {
-                    startTime: data.eventStartTime,
-                    endTime: data.eventEndTime,
-                },
-            ];
-        }
+    return currentUserIndex;
+  }
 
-        if (
-            restrictionTimes.restictionType === RestrictionType.Daily &&
-            restrictionTimes.dayRestrictionTimes
-        ) {
-            // before this we need to make sure restrciton times are moved to the day of the event.
-            restrictionTimes.dayRestrictionTimes.startTime =
-                OneUptimeDate.keepTimeButMoveDay(
-                    restrictionTimes.dayRestrictionTimes.startTime,
-                    data.eventStartTime
-                );
-
-            restrictionTimes.dayRestrictionTimes.endTime =
-                OneUptimeDate.keepTimeButMoveDay(
-                    restrictionTimes.dayRestrictionTimes.endTime,
-                    data.eventStartTime
-                );
-
-            return LayerUtil.getEventsByDailyRestriction({
-                eventStartTime: data.eventStartTime,
-                eventEndTime: data.eventEndTime,
-                restrictionStartAndEndTime:
-                    restrictionTimes.dayRestrictionTimes,
-                props: {
-                    intervalType: EventInterval.Day,
-                },
-            });
-        }
+  public static trimStartAndEndTimesBasedOnRestrictionTimes(data: {
+    eventStartTime: Date;
+    eventEndTime: Date;
+    restrictionTimes: RestrictionTimes;
+  }): Array<StartAndEndTime> {
+    const restrictionTimes: RestrictionTimes = data.restrictionTimes;
+
+    if (restrictionTimes.restictionType === RestrictionType.None) {
+      return [
+        {
+          startTime: data.eventStartTime,
+          endTime: data.eventEndTime,
+        },
+      ];
+    }
 
-        if (restrictionTimes.restictionType === RestrictionType.Weekly) {
-            return LayerUtil.getEventsByWeeklyRestriction(data);
-        }
+    if (
+      restrictionTimes.restictionType === RestrictionType.Daily &&
+      restrictionTimes.dayRestrictionTimes
+    ) {
+      // before this we need to make sure restrciton times are moved to the day of the event.
+      restrictionTimes.dayRestrictionTimes.startTime =
+        OneUptimeDate.keepTimeButMoveDay(
+          restrictionTimes.dayRestrictionTimes.startTime,
+          data.eventStartTime,
+        );
 
-        return [];
+      restrictionTimes.dayRestrictionTimes.endTime =
+        OneUptimeDate.keepTimeButMoveDay(
+          restrictionTimes.dayRestrictionTimes.endTime,
+          data.eventStartTime,
+        );
+
+      return LayerUtil.getEventsByDailyRestriction({
+        eventStartTime: data.eventStartTime,
+        eventEndTime: data.eventEndTime,
+        restrictionStartAndEndTime: restrictionTimes.dayRestrictionTimes,
+        props: {
+          intervalType: EventInterval.Day,
+        },
+      });
     }
 
-    public static getEventsByWeeklyRestriction(data: {
-        eventStartTime: Date;
-        eventEndTime: Date;
-        restrictionTimes: RestrictionTimes;
-    }): Array<StartAndEndTime> {
-        const weeklyRestrictionTimes: Array<WeeklyResctriction> =
-            data.restrictionTimes.weeklyRestrictionTimes;
+    if (restrictionTimes.restictionType === RestrictionType.Weekly) {
+      return LayerUtil.getEventsByWeeklyRestriction(data);
+    }
 
-        // if there are no weekly restriction times, we dont have any restrictions and we can return the event start and end times
+    return [];
+  }
 
-        let trimmedStartAndEndTimes: Array<StartAndEndTime> = [];
+  public static getEventsByWeeklyRestriction(data: {
+    eventStartTime: Date;
+    eventEndTime: Date;
+    restrictionTimes: RestrictionTimes;
+  }): Array<StartAndEndTime> {
+    const weeklyRestrictionTimes: Array<WeeklyResctriction> =
+      data.restrictionTimes.weeklyRestrictionTimes;
 
-        if (!weeklyRestrictionTimes || weeklyRestrictionTimes.length === 0) {
-            return [
-                {
-                    startTime: data.eventStartTime,
-                    endTime: data.eventEndTime,
-                },
-            ];
-        }
+    // if there are no weekly restriction times, we dont have any restrictions and we can return the event start and end times
 
-        const restrictionStartAndEndTimes: Array<StartAndEndTime> =
-            LayerUtil.getWeeklyRestrictionTimesForWeek(data);
-
-        for (const restrictionStartAndEndTime of restrictionStartAndEndTimes) {
-            const trimmedStartAndEndTimesForRestriction: Array<StartAndEndTime> =
-                LayerUtil.getEventsByDailyRestriction({
-                    eventStartTime: data.eventStartTime,
-                    eventEndTime: data.eventEndTime,
-                    restrictionStartAndEndTime: restrictionStartAndEndTime,
-                    props: {
-                        intervalType: EventInterval.Week,
-                    },
-                });
-
-            trimmedStartAndEndTimes = [
-                ...trimmedStartAndEndTimes,
-                ...trimmedStartAndEndTimesForRestriction,
-            ];
-        }
+    let trimmedStartAndEndTimes: Array<StartAndEndTime> = [];
 
-        return trimmedStartAndEndTimes;
+    if (!weeklyRestrictionTimes || weeklyRestrictionTimes.length === 0) {
+      return [
+        {
+          startTime: data.eventStartTime,
+          endTime: data.eventEndTime,
+        },
+      ];
+    }
+
+    const restrictionStartAndEndTimes: Array<StartAndEndTime> =
+      LayerUtil.getWeeklyRestrictionTimesForWeek(data);
+
+    for (const restrictionStartAndEndTime of restrictionStartAndEndTimes) {
+      const trimmedStartAndEndTimesForRestriction: Array<StartAndEndTime> =
+        LayerUtil.getEventsByDailyRestriction({
+          eventStartTime: data.eventStartTime,
+          eventEndTime: data.eventEndTime,
+          restrictionStartAndEndTime: restrictionStartAndEndTime,
+          props: {
+            intervalType: EventInterval.Week,
+          },
+        });
+
+      trimmedStartAndEndTimes = [
+        ...trimmedStartAndEndTimes,
+        ...trimmedStartAndEndTimesForRestriction,
+      ];
     }
 
-    public static getWeeklyRestrictionTimesForWeek(data: {
-        eventStartTime: Date;
-        eventEndTime: Date;
-        restrictionTimes: RestrictionTimes;
-    }): Array<StartAndEndTime> {
-        const weeklyRestrictionTimes: Array<WeeklyResctriction> =
-            data.restrictionTimes.weeklyRestrictionTimes;
+    return trimmedStartAndEndTimes;
+  }
 
-        const eventStartTime: Date = data.eventStartTime;
+  public static getWeeklyRestrictionTimesForWeek(data: {
+    eventStartTime: Date;
+    eventEndTime: Date;
+    restrictionTimes: RestrictionTimes;
+  }): Array<StartAndEndTime> {
+    const weeklyRestrictionTimes: Array<WeeklyResctriction> =
+      data.restrictionTimes.weeklyRestrictionTimes;
 
-        const startAndEndTimesOfWeeklyRestrictions: Array<StartAndEndTime> = [];
+    const eventStartTime: Date = data.eventStartTime;
 
-        for (const weeklyRestriction of weeklyRestrictionTimes) {
-            // move all of these to the week of the event start time
+    const startAndEndTimesOfWeeklyRestrictions: Array<StartAndEndTime> = [];
 
-            const startDayOfWeek: DayOfWeek = weeklyRestriction.startDay;
-            const endDayOfWeek: DayOfWeek = weeklyRestriction.endDay;
+    for (const weeklyRestriction of weeklyRestrictionTimes) {
+      // move all of these to the week of the event start time
 
-            let startTime: Date = weeklyRestriction.startTime;
-            let endTime: Date = weeklyRestriction.endTime;
+      const startDayOfWeek: DayOfWeek = weeklyRestriction.startDay;
+      const endDayOfWeek: DayOfWeek = weeklyRestriction.endDay;
 
-            // move start and end times to the week of the event start time
+      let startTime: Date = weeklyRestriction.startTime;
+      let endTime: Date = weeklyRestriction.endTime;
 
-            startTime = OneUptimeDate.moveDateToTheDayOfWeek(
-                startTime,
-                eventStartTime,
-                startDayOfWeek
-            );
-            endTime = OneUptimeDate.moveDateToTheDayOfWeek(
-                endTime,
-                eventStartTime,
-                endDayOfWeek
-            );
+      // move start and end times to the week of the event start time
 
-            // now we have true start and end times of the weekly restriction
+      startTime = OneUptimeDate.moveDateToTheDayOfWeek(
+        startTime,
+        eventStartTime,
+        startDayOfWeek,
+      );
+      endTime = OneUptimeDate.moveDateToTheDayOfWeek(
+        endTime,
+        eventStartTime,
+        endDayOfWeek,
+      );
 
-            // if start time is after end time, we need to add one week to the end time
+      // now we have true start and end times of the weekly restriction
 
-            if (OneUptimeDate.isAfter(startTime, endTime)) {
-                endTime = OneUptimeDate.addRemoveWeeks(endTime, 1);
-            }
+      // if start time is after end time, we need to add one week to the end time
 
-            startAndEndTimesOfWeeklyRestrictions.push({
-                startTime,
-                endTime,
-            });
-        }
+      if (OneUptimeDate.isAfter(startTime, endTime)) {
+        endTime = OneUptimeDate.addRemoveWeeks(endTime, 1);
+      }
 
-        return startAndEndTimesOfWeeklyRestrictions;
+      startAndEndTimesOfWeeklyRestrictions.push({
+        startTime,
+        endTime,
+      });
     }
 
-    public static getEventsByDailyRestriction(data: {
-        eventStartTime: Date;
-        eventEndTime: Date;
-        restrictionStartAndEndTime: StartAndEndTime;
-        props: {
-            intervalType: EventInterval;
-        };
-    }): Array<StartAndEndTime> {
-        const dayRestrictionTimes: StartAndEndTime | null =
-            data.restrictionStartAndEndTime;
-
-        // if there are no day restriction times, we dont have any restrictions and we can return the event start and end times
-
-        if (!dayRestrictionTimes) {
-            return [
-                {
-                    startTime: data.eventStartTime,
-                    endTime: data.eventEndTime,
-                },
-            ];
-        }
+    return startAndEndTimesOfWeeklyRestrictions;
+  }
+
+  public static getEventsByDailyRestriction(data: {
+    eventStartTime: Date;
+    eventEndTime: Date;
+    restrictionStartAndEndTime: StartAndEndTime;
+    props: {
+      intervalType: EventInterval;
+    };
+  }): Array<StartAndEndTime> {
+    const dayRestrictionTimes: StartAndEndTime | null =
+      data.restrictionStartAndEndTime;
+
+    // if there are no day restriction times, we dont have any restrictions and we can return the event start and end times
+
+    if (!dayRestrictionTimes) {
+      return [
+        {
+          startTime: data.eventStartTime,
+          endTime: data.eventEndTime,
+        },
+      ];
+    }
 
-        //
+    //
 
-        let restrictionStartTime: Date = dayRestrictionTimes.startTime;
-        let restrictionEndTime: Date = dayRestrictionTimes.endTime;
+    let restrictionStartTime: Date = dayRestrictionTimes.startTime;
+    let restrictionEndTime: Date = dayRestrictionTimes.endTime;
 
-        let currentStartTime: Date = data.eventStartTime;
-        const currentEndTime: Date = data.eventEndTime;
+    let currentStartTime: Date = data.eventStartTime;
+    const currentEndTime: Date = data.eventEndTime;
 
-        const trimmedStartAndEndTimes: Array<StartAndEndTime> = [];
+    const trimmedStartAndEndTimes: Array<StartAndEndTime> = [];
 
-        let reachedTheEndOfTheCurrentEvent: boolean = false;
+    let reachedTheEndOfTheCurrentEvent: boolean = false;
 
-        while (!reachedTheEndOfTheCurrentEvent) {
-            // if current end time is equalto or before than the current start time, we need to return the current event and exit the loop
+    while (!reachedTheEndOfTheCurrentEvent) {
+      // if current end time is equalto or before than the current start time, we need to return the current event and exit the loop
 
-            if (OneUptimeDate.isBefore(currentEndTime, currentStartTime)) {
-                reachedTheEndOfTheCurrentEvent = true;
-            }
+      if (OneUptimeDate.isBefore(currentEndTime, currentStartTime)) {
+        reachedTheEndOfTheCurrentEvent = true;
+      }
 
-            // if the event is ourside the restriction times, we need to return the trimmed array
+      // if the event is ourside the restriction times, we need to return the trimmed array
 
-            if (OneUptimeDate.isAfter(restrictionStartTime, currentEndTime)) {
-                return trimmedStartAndEndTimes;
-            }
+      if (OneUptimeDate.isAfter(restrictionStartTime, currentEndTime)) {
+        return trimmedStartAndEndTimes;
+      }
 
-            // if current event start time is after the restriction end time then we need to return empty array as there is no event.
+      // if current event start time is after the restriction end time then we need to return empty array as there is no event.
 
-            if (OneUptimeDate.isAfter(currentStartTime, restrictionEndTime)) {
-                return trimmedStartAndEndTimes;
-            }
+      if (OneUptimeDate.isAfter(currentStartTime, restrictionEndTime)) {
+        return trimmedStartAndEndTimes;
+      }
 
-            // if the restriction end time is before the restriction start time, we need to add one day to the restriction end time
-            if (
-                OneUptimeDate.isAfter(restrictionStartTime, restrictionEndTime)
-            ) {
-                restrictionEndTime = OneUptimeDate.addRemoveDays(
-                    restrictionEndTime,
-                    data.props.intervalType === EventInterval.Day ? 1 : 7 // daily or weekly
-                );
-            }
+      // if the restriction end time is before the restriction start time, we need to add one day to the restriction end time
+      if (OneUptimeDate.isAfter(restrictionStartTime, restrictionEndTime)) {
+        restrictionEndTime = OneUptimeDate.addRemoveDays(
+          restrictionEndTime,
+          data.props.intervalType === EventInterval.Day ? 1 : 7, // daily or weekly
+        );
+      }
 
-            // 1 - if the current event falls within the restriction times, we need to return the current event.
-
-            if (
-                OneUptimeDate.isOnOrAfter(
-                    currentStartTime,
-                    restrictionStartTime
-                ) &&
-                OneUptimeDate.isOnOrAfter(restrictionEndTime, currentEndTime)
-            ) {
-                trimmedStartAndEndTimes.push({
-                    startTime: currentStartTime,
-                    endTime: currentEndTime,
-                });
-                reachedTheEndOfTheCurrentEvent = true;
-            }
+      // 1 - if the current event falls within the restriction times, we need to return the current event.
 
-            // 2 - Start Restriction: If the current event starts after the restriction start time and ends after the restriction end time, we need to return the current event with the start time of the current event and end time of the restriction
-
-            if (
-                OneUptimeDate.isOnOrAfter(
-                    currentStartTime,
-                    restrictionStartTime
-                ) &&
-                OneUptimeDate.isOnOrAfter(currentEndTime, restrictionEndTime)
-            ) {
-                trimmedStartAndEndTimes.push({
-                    startTime: currentStartTime,
-                    endTime: restrictionEndTime,
-                });
-                reachedTheEndOfTheCurrentEvent = true;
-            }
+      if (
+        OneUptimeDate.isOnOrAfter(currentStartTime, restrictionStartTime) &&
+        OneUptimeDate.isOnOrAfter(restrictionEndTime, currentEndTime)
+      ) {
+        trimmedStartAndEndTimes.push({
+          startTime: currentStartTime,
+          endTime: currentEndTime,
+        });
+        reachedTheEndOfTheCurrentEvent = true;
+      }
+
+      // 2 - Start Restriction: If the current event starts after the restriction start time and ends after the restriction end time, we need to return the current event with the start time of the current event and end time of the restriction
+
+      if (
+        OneUptimeDate.isOnOrAfter(currentStartTime, restrictionStartTime) &&
+        OneUptimeDate.isOnOrAfter(currentEndTime, restrictionEndTime)
+      ) {
+        trimmedStartAndEndTimes.push({
+          startTime: currentStartTime,
+          endTime: restrictionEndTime,
+        });
+        reachedTheEndOfTheCurrentEvent = true;
+      }
+
+      // 3 - End Restriction - If the current event starts before the restriction start time and ends before the restriction end time, we need to return the current event with the start time of the restriction and end time of the current event.
+
+      if (
+        OneUptimeDate.isBefore(currentStartTime, restrictionStartTime) &&
+        OneUptimeDate.isBefore(currentEndTime, restrictionEndTime) &&
+        OneUptimeDate.isAfter(currentEndTime, restrictionStartTime)
+      ) {
+        trimmedStartAndEndTimes.push({
+          startTime: restrictionStartTime,
+          endTime: currentEndTime,
+        });
+        reachedTheEndOfTheCurrentEvent = true;
+      }
+
+      // 4 - If the current event starts before the restriction start time and ends after the restriction end time, we need to return the current event with the start time of the restriction and end time of the restriction.
+
+      if (
+        OneUptimeDate.isBefore(currentStartTime, restrictionStartTime) &&
+        OneUptimeDate.isOnOrAfter(currentEndTime, restrictionEndTime)
+      ) {
+        trimmedStartAndEndTimes.push({
+          startTime: restrictionStartTime,
+          endTime: restrictionEndTime,
+        });
 
-            // 3 - End Restriction - If the current event starts before the restriction start time and ends before the restriction end time, we need to return the current event with the start time of the restriction and end time of the current event.
-
-            if (
-                OneUptimeDate.isBefore(
-                    currentStartTime,
-                    restrictionStartTime
-                ) &&
-                OneUptimeDate.isBefore(currentEndTime, restrictionEndTime) &&
-                OneUptimeDate.isAfter(currentEndTime, restrictionStartTime)
-            ) {
-                trimmedStartAndEndTimes.push({
-                    startTime: restrictionStartTime,
-                    endTime: currentEndTime,
-                });
-                reachedTheEndOfTheCurrentEvent = true;
-            }
+        currentStartTime = OneUptimeDate.addRemoveSeconds(
+          restrictionEndTime,
+          1,
+        );
 
-            // 4 - If the current event starts before the restriction start time and ends after the restriction end time, we need to return the current event with the start time of the restriction and end time of the restriction.
-
-            if (
-                OneUptimeDate.isBefore(
-                    currentStartTime,
-                    restrictionStartTime
-                ) &&
-                OneUptimeDate.isOnOrAfter(currentEndTime, restrictionEndTime)
-            ) {
-                trimmedStartAndEndTimes.push({
-                    startTime: restrictionStartTime,
-                    endTime: restrictionEndTime,
-                });
-
-                currentStartTime = OneUptimeDate.addRemoveSeconds(
-                    restrictionEndTime,
-                    1
-                );
-
-                // add day to restriction start and end times.
-
-                restrictionStartTime = OneUptimeDate.addRemoveDays(
-                    restrictionStartTime,
-                    data.props.intervalType === EventInterval.Day ? 1 : 7 // daily or weekly
-                );
-                restrictionEndTime = OneUptimeDate.addRemoveDays(
-                    restrictionEndTime,
-                    data.props.intervalType === EventInterval.Day ? 1 : 7 // daily or weekly
-                );
-            }
-        }
+        // add day to restriction start and end times.
 
-        return trimmedStartAndEndTimes;
+        restrictionStartTime = OneUptimeDate.addRemoveDays(
+          restrictionStartTime,
+          data.props.intervalType === EventInterval.Day ? 1 : 7, // daily or weekly
+        );
+        restrictionEndTime = OneUptimeDate.addRemoveDays(
+          restrictionEndTime,
+          data.props.intervalType === EventInterval.Day ? 1 : 7, // daily or weekly
+        );
+      }
     }
 
-    // helper functions.
+    return trimmedStartAndEndTimes;
+  }
 
-    private static incrementUserIndex(
-        currentIndex: number,
-        userArrayLength: number,
-        incrementBy?: number
-    ): number {
-        // update the current user index
+  // helper functions.
 
-        if (incrementBy === undefined) {
-            incrementBy = 1;
-        }
+  private static incrementUserIndex(
+    currentIndex: number,
+    userArrayLength: number,
+    incrementBy?: number,
+  ): number {
+    // update the current user index
 
-        currentIndex = currentIndex + incrementBy;
+    if (incrementBy === undefined) {
+      incrementBy = 1;
+    }
 
-        // if the current user index is greater than the length of the users array, we need to reset the current user index to 0
-        if (currentIndex >= userArrayLength) {
-            // then modulo the current user index by the length of the users array
-            currentIndex = currentIndex % userArrayLength; // so this rotates the users.
-        }
+    currentIndex = currentIndex + incrementBy;
 
-        return currentIndex;
+    // if the current user index is greater than the length of the users array, we need to reset the current user index to 0
+    if (currentIndex >= userArrayLength) {
+      // then modulo the current user index by the length of the users array
+      currentIndex = currentIndex % userArrayLength; // so this rotates the users.
     }
 
-    private static getCalendarEventsFromStartAndEndDates(
-        trimmedStartAndEndTimes: Array<StartAndEndTime>,
-        users: Array<UserModel>,
-        currentUserIndex: number
-    ): Array<CalendarEvent> {
-        const events: Array<CalendarEvent> = [];
+    return currentIndex;
+  }
 
-        const userId: string = users[currentUserIndex]?.id?.toString() || '';
+  private static getCalendarEventsFromStartAndEndDates(
+    trimmedStartAndEndTimes: Array<StartAndEndTime>,
+    users: Array<UserModel>,
+    currentUserIndex: number,
+  ): Array<CalendarEvent> {
+    const events: Array<CalendarEvent> = [];
 
-        for (const trimmedStartAndEndTime of trimmedStartAndEndTimes) {
-            const event: CalendarEvent = {
-                id: 0,
-                title: userId, // This will be changed to username in the UI or will bve kept the same if used on the server.
-                allDay: false,
-                start: trimmedStartAndEndTime.startTime,
-                end: trimmedStartAndEndTime.endTime,
-            };
+    const userId: string = users[currentUserIndex]?.id?.toString() || "";
 
-            events.push(event);
-        }
+    for (const trimmedStartAndEndTime of trimmedStartAndEndTimes) {
+      const event: CalendarEvent = {
+        id: 0,
+        title: userId, // This will be changed to username in the UI or will bve kept the same if used on the server.
+        allDay: false,
+        start: trimmedStartAndEndTime.startTime,
+        end: trimmedStartAndEndTime.endTime,
+      };
 
-        return events;
+      events.push(event);
     }
 
-    public static getMultiLayerEvents(
-        data: MultiLayerProps
-    ): Array<CalendarEvent> {
-        const events: Array<PriorityCalendarEvents> = [];
-        let layerPriority: number = 1;
+    return events;
+  }
+
+  public static getMultiLayerEvents(
+    data: MultiLayerProps,
+  ): Array<CalendarEvent> {
+    const events: Array<PriorityCalendarEvents> = [];
+    let layerPriority: number = 1;
+
+    for (const layer of data.layers) {
+      const layerEvents: Array<CalendarEvent> = LayerUtil.getEvents({
+        users: layer.users,
+        startDateTimeOfLayer: layer.startDateTimeOfLayer,
+        restrictionTimes: layer.restrictionTimes,
+        handOffTime: layer.handOffTime,
+        rotation: layer.rotation,
+        calendarStartDate: data.calendarStartDate,
+        calendarEndDate: data.calendarEndDate,
+      });
+
+      // add priority to each event
+
+      for (const layerEvent of layerEvents) {
+        const priorityEvent: PriorityCalendarEvents = {
+          ...layerEvent,
+          priority: layerPriority,
+        };
 
-        for (const layer of data.layers) {
-            const layerEvents: Array<CalendarEvent> = LayerUtil.getEvents({
-                users: layer.users,
-                startDateTimeOfLayer: layer.startDateTimeOfLayer,
-                restrictionTimes: layer.restrictionTimes,
-                handOffTime: layer.handOffTime,
-                rotation: layer.rotation,
-                calendarStartDate: data.calendarStartDate,
-                calendarEndDate: data.calendarEndDate,
-            });
+        events.push(priorityEvent);
+      }
 
-            // add priority to each event
+      // increment layer priority
+      layerPriority++;
+    }
 
-            for (const layerEvent of layerEvents) {
-                const priorityEvent: PriorityCalendarEvents = {
-                    ...layerEvent,
-                    priority: layerPriority,
-                };
+    // now remove the overlapping events
 
-                events.push(priorityEvent);
-            }
+    const nonOverlappingEvents: Array<CalendarEvent> =
+      LayerUtil.removeOverlappingEvents(events);
 
-            // increment layer priority
-            layerPriority++;
-        }
+    return nonOverlappingEvents;
+  }
 
-        // now remove the overlapping events
+  public static removeOverlappingEvents(
+    events: PriorityCalendarEvents[],
+  ): CalendarEvent[] {
+    // now remove overlapping events by priority and trim them by priority. Lower priority number will be kept and higher priority number will be trimmed.
+    // so if there are two events with the same start and end time, we will keep the one with the lower priority number and remove the one with the higher priority number.
+    // if there are overlapping events, we will trim the one with the higher priority number.
 
-        const nonOverlappingEvents: Array<CalendarEvent> =
-            LayerUtil.removeOverlappingEvents(events);
+    // sort the events by priority
 
-        return nonOverlappingEvents;
-    }
+    // now remove the overlapping events
 
-    public static removeOverlappingEvents(
-        events: PriorityCalendarEvents[]
-    ): CalendarEvent[] {
-        // now remove overlapping events by priority and trim them by priority. Lower priority number will be kept and higher priority number will be trimmed.
-        // so if there are two events with the same start and end time, we will keep the one with the lower priority number and remove the one with the higher priority number.
-        // if there are overlapping events, we will trim the one with the higher priority number.
+    const finalEvents: PriorityCalendarEvents[] = [];
 
-        // sort the events by priority
+    // sort events by start time
 
-        // now remove the overlapping events
+    events.sort((a: CalendarEvent, b: CalendarEvent) => {
+      if (OneUptimeDate.isBefore(a.start, b.start)) {
+        return -1;
+      }
 
-        const finalEvents: PriorityCalendarEvents[] = [];
+      if (OneUptimeDate.isAfter(a.start, b.start)) {
+        return 1;
+      }
 
-        // sort events by start time
+      return 0;
+    });
 
-        events.sort((a: CalendarEvent, b: CalendarEvent) => {
-            if (OneUptimeDate.isBefore(a.start, b.start)) {
-                return -1;
-            }
+    for (const event of events) {
+      // trim the trimmed events by the current event based on priority
 
-            if (OneUptimeDate.isAfter(a.start, b.start)) {
-                return 1;
-            }
+      for (const finalEvent of finalEvents) {
+        // check if this final event overlaps with the current event
 
-            return 0;
-        });
+        if (
+          OneUptimeDate.isOverlapping(
+            finalEvent.start,
+            finalEvent.end,
+            event.start,
+            event.end,
+          )
+        ) {
+          // if the current event has a higher priority than the final event, we need to trim the final event
 
-        for (const event of events) {
-            // trim the trimmed events by the current event based on priority
-
-            for (const finalEvent of finalEvents) {
-                // check if this final event overlaps with the current event
-
-                if (
-                    OneUptimeDate.isOverlapping(
-                        finalEvent.start,
-                        finalEvent.end,
-                        event.start,
-                        event.end
-                    )
-                ) {
-                    // if the current event has a higher priority than the final event, we need to trim the final event
-
-                    if (event.priority < finalEvent.priority) {
-                        // trim the final event based on the current event
-                        // end time of the final event  will be the start time of the current event - 1 second
-
-                        const tempFinalEventEnd: Date = finalEvent.end;
-
-                        finalEvent.end = OneUptimeDate.addRemoveSeconds(
-                            event.start,
-                            -1
-                        );
-
-                        // final event was originally ending after the current event, so we need to add the trimmed event to the final events array
-
-                        if (
-                            OneUptimeDate.isAfter(tempFinalEventEnd, event.end)
-                        ) {
-                            // add the trimmed event to the final events array
-
-                            const trimmedEvent: PriorityCalendarEvents = {
-                                ...finalEvent,
-                                priority: finalEvent.priority,
-                                start: OneUptimeDate.addRemoveSeconds(
-                                    event.end,
-                                    1
-                                ),
-                                end: tempFinalEventEnd,
-                            };
-
-                            finalEvents.push(trimmedEvent);
-                        }
-                    } else {
-                        // trim the current event based on the final event
-                        // start time of the current event will be the end time of the final event + 1 second
-                        event.start = OneUptimeDate.addRemoveSeconds(
-                            finalEvent.end,
-                            1
-                        );
-                    }
-                }
-            }
+          if (event.priority < finalEvent.priority) {
+            // trim the final event based on the current event
+            // end time of the final event  will be the start time of the current event - 1 second
 
-            finalEvents.push(event);
+            const tempFinalEventEnd: Date = finalEvent.end;
 
-            // sort by start times
+            finalEvent.end = OneUptimeDate.addRemoveSeconds(event.start, -1);
 
-            finalEvents.sort((a: CalendarEvent, b: CalendarEvent) => {
-                if (OneUptimeDate.isBefore(a.start, b.start)) {
-                    return -1;
-                }
+            // final event was originally ending after the current event, so we need to add the trimmed event to the final events array
 
-                if (OneUptimeDate.isAfter(a.start, b.start)) {
-                    return 1;
-                }
+            if (OneUptimeDate.isAfter(tempFinalEventEnd, event.end)) {
+              // add the trimmed event to the final events array
 
-                return 0;
-            });
+              const trimmedEvent: PriorityCalendarEvents = {
+                ...finalEvent,
+                priority: finalEvent.priority,
+                start: OneUptimeDate.addRemoveSeconds(event.end, 1),
+                end: tempFinalEventEnd,
+              };
 
-            // if an event starts and end at the same time, we need to remove it
+              finalEvents.push(trimmedEvent);
+            }
+          } else {
+            // trim the current event based on the final event
+            // start time of the current event will be the end time of the final event + 1 second
+            event.start = OneUptimeDate.addRemoveSeconds(finalEvent.end, 1);
+          }
+        }
+      }
+
+      finalEvents.push(event);
 
-            finalEvents.forEach((finalEvent: CalendarEvent, index: number) => {
-                if (OneUptimeDate.isSame(finalEvent.start, finalEvent.end)) {
-                    finalEvents.splice(index, 1);
-                }
+      // sort by start times
 
-                // if any event ends before it starts, we need to remove it
+      finalEvents.sort((a: CalendarEvent, b: CalendarEvent) => {
+        if (OneUptimeDate.isBefore(a.start, b.start)) {
+          return -1;
+        }
 
-                if (OneUptimeDate.isBefore(finalEvent.end, finalEvent.start)) {
-                    finalEvents.splice(index, 1);
-                }
-            });
+        if (OneUptimeDate.isAfter(a.start, b.start)) {
+          return 1;
         }
 
-        // convert PriorityCalendarEvents to CalendarEvents
+        return 0;
+      });
 
-        const calendarEvents: CalendarEvent[] = [];
-        let id: number = 1;
+      // if an event starts and end at the same time, we need to remove it
+
+      finalEvents.forEach((finalEvent: CalendarEvent, index: number) => {
+        if (OneUptimeDate.isSame(finalEvent.start, finalEvent.end)) {
+          finalEvents.splice(index, 1);
+        }
 
-        for (const event of finalEvents) {
-            const calendarEvent: CalendarEvent = {
-                ...event,
-                id: id,
-            };
+        // if any event ends before it starts, we need to remove it
 
-            calendarEvents.push(calendarEvent);
-            id++;
+        if (OneUptimeDate.isBefore(finalEvent.end, finalEvent.start)) {
+          finalEvents.splice(index, 1);
         }
+      });
+    }
+
+    // convert PriorityCalendarEvents to CalendarEvents
+
+    const calendarEvents: CalendarEvent[] = [];
+    let id: number = 1;
 
-        return calendarEvents;
+    for (const event of finalEvents) {
+      const calendarEvent: CalendarEvent = {
+        ...event,
+        id: id,
+      };
+
+      calendarEvents.push(calendarEvent);
+      id++;
     }
+
+    return calendarEvents;
+  }
 }