refactor: small tweaks and fixes

apps/server/src/services/TimerService.ts

@@ -142,17 +142,18 @@ function broadcastResult(_target: any, _propertyKey: string, descriptor: Propert
     const isTimeToUpdate = state.clock - TimerService.previousUpdate >= TimerService._updateInterval;
 
     // some changes need an immediate update
+    const hasNewLoaded = state.eventNow?.id !== TimerService.previousState?.eventNow?.id;
     const hasSkippedBack = state.clock < TimerService.previousUpdate;
     const justStarted = !TimerService.previousState?.timer;
     const hasChangedPlayback = TimerService.previousState.timer?.playback !== state.timer.playback;
-    const hasImmediateChanges = hasSkippedBack || justStarted || hasChangedPlayback;
+    const hasImmediateChanges = hasNewLoaded || hasSkippedBack || justStarted || hasChangedPlayback;
 
     if (hasImmediateChanges || (isTimeToUpdate && !deepEqual(TimerService.previousState?.timer, state.timer))) {
       eventStore.set('timer', state.timer);
       TimerService.previousState.timer = { ...state.timer };
     }
 
-    if (isTimeToUpdate && !deepEqual(TimerService.previousState?.runtime, state.runtime)) {
+    if (hasChangedPlayback || (isTimeToUpdate && !deepEqual(TimerService.previousState?.runtime, state.runtime))) {
       eventStore.set('runtime', state.runtime);
       TimerService.previousState.runtime = { ...state.runtime };
     }

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

@@ -1387,6 +1387,9 @@ describe('getRuntimeOffset()', () => {
       _timer: {
         pausedAt: null,
       },
+      runtime: {
+        actualStart: 150,
+      },
     } as RuntimeState;
 
     const offset = getRuntimeOffset(state);
@@ -1408,6 +1411,9 @@ describe('getRuntimeOffset()', () => {
       _timer: {
         pausedAt: null,
       },
+      runtime: {
+        actualStart: 100,
+      },
     } as RuntimeState;
 
     const offset = getRuntimeOffset(state);
@@ -1430,9 +1436,116 @@ describe('getRuntimeOffset()', () => {
       _timer: {
         pausedAt: 125,
       },
+      runtime: {
+        actualStart: 100,
+      },
     } as RuntimeState;
 
     const offset = getRuntimeOffset(state);
     expect(offset).toBe(25);
   });
+
+  it('can only count once started', () => {
+    const state = {
+      clock: 78480789,
+      eventNow: {
+        id: 'd6a2ce',
+        type: 'event',
+        title: '',
+        timeStart: 77400000,
+        timeEnd: 81000000,
+        duration: 3600000,
+        timeStrategy: 'lock-duration',
+        linkStart: null,
+        endAction: 'none',
+        timerType: 'count-down',
+        isPublic: true,
+        skip: false,
+        note: '',
+        colour: '',
+        cue: '1',
+        revision: 0,
+        timeWarning: 120000,
+        timeDanger: 60000,
+        custom: {},
+        delay: 0,
+      },
+      runtime: {
+        selectedEventIndex: 0,
+        numEvents: 2,
+        offset: -77400000,
+        plannedStart: 77400000,
+        plannedEnd: 84600000,
+        actualStart: null,
+        expectedEnd: null,
+      },
+      timer: {
+        addedTime: 0,
+        current: 3600000,
+        duration: 3600000,
+        elapsed: null,
+        expectedFinish: null,
+        finishedAt: null,
+        playback: 'armed',
+        secondaryTimer: null,
+        startedAt: null,
+      },
+      _timer: { pausedAt: null, secondaryTarget: null, finishedNow: false },
+    } as RuntimeState;
+
+    const offset = getRuntimeOffset(state);
+    expect(offset).toBe(null);
+  });
+
+  it('handles loaded event', () => {
+    const state = {
+      clock: 79521653,
+      eventNow: {
+        id: '835242',
+        type: 'event',
+        title: '',
+        timeStart: 81000000,
+        timeEnd: 84600000,
+        duration: 3600000,
+        timeStrategy: 'lock-duration',
+        linkStart: null,
+        endAction: 'none',
+        timerType: 'count-down',
+        isPublic: true,
+        skip: false,
+        note: '',
+        colour: '',
+        cue: '2',
+        revision: 0,
+        timeWarning: 120000,
+        timeDanger: 60000,
+        custom: {},
+        delay: 0,
+      },
+      runtime: {
+        selectedEventIndex: 1,
+        numEvents: 2,
+        offset: -81000000,
+        plannedStart: 77400000,
+        plannedEnd: 84600000,
+        actualStart: 79443403,
+        expectedEnd: null,
+      },
+      timer: {
+        addedTime: 0,
+        current: 3600000,
+        duration: 3600000,
+        elapsed: null,
+        expectedFinish: null,
+        finishedAt: null,
+        playback: 'armed',
+        secondaryTimer: null,
+        startedAt: null,
+      },
+      _timer: { pausedAt: null, secondaryTarget: null, finishedNow: false },
+    } as RuntimeState;
+
+    const offset = getRuntimeOffset(state);
+    expect(offset).toBe(79521653 - 81000000);
+  });
 });

apps/server/src/services/project-service/ProjectService.ts

@@ -14,6 +14,7 @@ import { appStateService } from '../app-state-service/AppStateService.js';
 import { ensureDirectory, getFilesFromFolder, removeFileExtension } from '../../utils/fileManagement.js';
 import { dbModel } from '../../models/dataModel.js';
 import { deleteFile } from '../../utils/parserUtils.js';
+import { switchDb } from '../../setup/loadDb.js';
 
 // init dependencies
 init();
@@ -40,6 +41,9 @@ export async function applyProjectFile(filePath: string, options?: Options) {
   const newFilePath = join(resolveProjectsDirectory, filename);
   await rename(filePath, newFilePath);
 
+  // change LowDB to point to new file
+  await switchDb(filename);
+
   // apply data model
   await applyDataModel(data, options);
 
@@ -135,6 +139,9 @@ export async function createProjectFile(filename: string, projectData: ProjectDa
   const newFile = join(resolveProjectsDirectory, filename);
   await writeFile(newFile, JSON.stringify(data));
 
+  // change LowDB to point to new file
+  await switchDb(filename);
+
   // apply its data
   await applyDataModel(data);
 

apps/server/src/services/runtime-service/RuntimeService.ts

@@ -191,10 +191,7 @@ class RuntimeService {
     }
 
     const timedEvents = getPlayableEvents();
-    const state = runtimeState.getState();
-    // TODO: return success boolean from runtimeState, when we work with optimising integrations
-    runtimeState.load(event, timedEvents);
-    const success = event.id === state.eventNow?.id;
+    const success = runtimeState.load(event, timedEvents);
 
     if (success) {
       integrationService.dispatch(TimerLifeCycle.onLoad);

apps/server/src/services/timerUtils.ts

@@ -292,20 +292,27 @@ export const updateRoll = (state: RuntimeState) => {
 
 /**
  * Calculates difference between the runtime and the schedule of an event
+ * Positive offset is a delay
+ * Negative offset is time ahead
  * @param state
  * @returns
  */
-export function getRuntimeOffset(state: RuntimeState): number {
-  if (state.eventNow === null) {
-    return 0;
+export function getRuntimeOffset(state: RuntimeState): MaybeNumber {
+  if (state.runtime.actualStart === null) {
+    return null;
   }
-
+  const { clock } = state;
   const { timeStart } = state.eventNow;
   const { addedTime, current, startedAt } = state.timer;
 
+  // if we havent started, the offset is the difference to the schedule
+  if (startedAt === null) {
+    return clock - timeStart;
+  }
+
   const overtime = Math.min(current, 0);
   const startOffset = startedAt - timeStart;
-  const pausedTime = state._timer.pausedAt === null ? 0 : state.clock - state._timer.pausedAt;
+  const pausedTime = state._timer.pausedAt === null ? 0 : clock - state._timer.pausedAt;
 
   return startOffset + addedTime + pausedTime + Math.abs(overtime);
 }