Over under (#771)

* feat: schedule offset

apps/server/src/services/RestoreService.ts

@@ -9,6 +9,7 @@ export type RestorePoint = {
   startedAt: MaybeNumber;
   addedTime: number;
   pausedAt: MaybeNumber;
+  firstStart: MaybeNumber;
 };
 
 /**
@@ -43,6 +44,10 @@ export function isRestorePoint(obj: unknown): obj is RestorePoint {
     return false;
   }
 
+  if (typeof restorePoint.firstStart !== 'number' && restorePoint.pausedAt !== null) {
+    return false;
+  }
+
   return true;
 }
 

apps/server/src/services/TimerService.ts

@@ -139,6 +139,7 @@ function broadcastResult(_target: any, _propertyKey: string, descriptor: Propert
       startedAt: state.timer.startedAt,
       addedTime: state.timer.addedTime,
       pausedAt: state._timer.pausedAt,
+      firstStart: state.runtime.actualStart,
     });
     return result;
   };

apps/server/src/services/__tests__/RestoreService.test.ts

@@ -13,6 +13,7 @@ describe('isRestorePoint()', () => {
       startedAt: 1,
       addedTime: 2,
       pausedAt: 3,
+      firstStart: 1,
     };
     expect(isRestorePoint(restorePoint)).toBe(true);
 
@@ -22,6 +23,7 @@ describe('isRestorePoint()', () => {
       startedAt: null,
       addedTime: 0,
       pausedAt: null,
+      firstStart: 1,
     };
     expect(isRestorePoint(restorePoint)).toBe(true);
   });
@@ -68,6 +70,7 @@ describe('RestoreService()', () => {
         startedAt: 1234,
         addedTime: 5678,
         pausedAt: 9087,
+        firstStart: 1234,
       };
 
       const restoreService = new RestoreService('/path/to/restore/file');
@@ -84,6 +87,7 @@ describe('RestoreService()', () => {
         startedAt: null,
         addedTime: 0,
         pausedAt: null,
+        firstStart: 1234,
       };
 
       const restoreService = new RestoreService('/path/to/restore/file');
@@ -100,6 +104,7 @@ describe('RestoreService()', () => {
         startedAt: 1234,
         addedTime: 1234,
         pausedAt: 1234,
+        firstStart: 1234,
       };
 
       const restoreService = new RestoreService('/path/to/restore/file');
@@ -118,6 +123,7 @@ describe('RestoreService()', () => {
         startedAt: 1234,
         addedTime: 1234,
         pausedAt: 1234,
+        firstStart: 1234,
       };
 
       const restoreService = new RestoreService('/path/to/restore/file');

apps/server/src/services/__tests__/timerUtils.test.ts

@@ -5,6 +5,7 @@ import {
   getCurrent,
   getExpectedFinish,
   getRollTimers,
+  getRuntimeOffset,
   normaliseEndTime,
   skippedOutOfEvent,
   updateRoll,
@@ -1370,3 +1371,68 @@ describe('updateRoll()', () => {
     expect(updateRoll(timers)).toStrictEqual(expected);
   });
 });
+
+describe('getRuntimeOffset()', () => {
+  it('calculates the difference between schedule and actual start', () => {
+    const state = {
+      eventNow: {
+        id: '1',
+        timeStart: 100,
+      },
+      timer: {
+        startedAt: 150,
+        addedTime: 10,
+        current: 0,
+      },
+      _timer: {
+        pausedAt: null,
+      },
+    } as RuntimeState;
+
+    const offset = getRuntimeOffset(state);
+    expect(offset).toBe(60);
+  });
+
+  it('adds the overtime time of the current timer', () => {
+    const state = {
+      eventNow: {
+        id: '1',
+        timeStart: 100,
+        timeEnd: 140,
+      },
+      timer: {
+        startedAt: 100,
+        current: -10,
+        addedTime: 0,
+      },
+      _timer: {
+        pausedAt: null,
+      },
+    } as RuntimeState;
+
+    const offset = getRuntimeOffset(state);
+    expect(offset).toBe(10);
+  });
+
+  it('accounts for paused time', () => {
+    const state = {
+      eventNow: {
+        id: '1',
+        timeStart: 100,
+        timeEnd: 150,
+      },
+      clock: 150,
+      timer: {
+        startedAt: 100,
+        current: 25,
+        addedTime: 0,
+      },
+      _timer: {
+        pausedAt: 125,
+      },
+    } as RuntimeState;
+
+    const offset = getRuntimeOffset(state);
+    expect(offset).toBe(25);
+  });
+});

apps/server/src/services/rundown-service/RundownService.ts

@@ -15,7 +15,7 @@ import { block as blockDef, delay as delayDef } from '../../models/eventsDefinit
 import { sendRefetch } from '../../adapters/websocketAux.js';
 import { logger } from '../../classes/Logger.js';
 import { createEvent } from '../../utils/parser.js';
-import { updateNumEvents } from '../../stores/runtimeState.js';
+import { updateRundownData } from '../../stores/runtimeState.js';
 import { runtimeService } from '../runtime-service/RuntimeService.js';
 
 import * as cache from './rundownCache.js';
@@ -159,8 +159,7 @@ export async function swapEvents(from: string, to: string) {
  * Called when we make changes to the rundown object
  */
 function updateChangeNumEvents() {
-  const numEvents = getPlayableEvents().length;
-  updateNumEvents(numEvents);
+  updateRundownData(getPlayableEvents());
 }
 
 /**
@@ -286,6 +285,10 @@ export function findNext(currentEventId?: string): OntimeEvent | null {
   return nextEvent ?? null;
 }
 
+/**
+ * Overrides the rundown with the given
+ * @param rundown
+ */
 export async function setRundown(rundown: OntimeRundown) {
   cache.init(rundown);
   notifyChanges({ timer: true });

apps/server/src/services/timerUtils.ts

@@ -289,3 +289,23 @@ export const updateRoll = (state: RuntimeState) => {
 
   return { updatedTimer, updatedSecondaryTimer, doRollLoad, isFinished: isPrimaryFinished };
 };
+
+/**
+ * Calculates difference between the runtime and the schedule of an event
+ * @param state
+ * @returns
+ */
+export function getRuntimeOffset(state: RuntimeState): number {
+  if (state.eventNow === null) {
+    return 0;
+  }
+
+  const { timeStart } = state.eventNow;
+  const { addedTime, current, startedAt } = state.timer;
+
+  const overtime = Math.min(current, 0);
+  const startOffset = startedAt - timeStart;
+  const pausedTime = state._timer.pausedAt === null ? 0 : state.clock - state._timer.pausedAt;
+
+  return startOffset + addedTime + pausedTime + Math.abs(overtime);
+}