refactor: UI for linking events (#763)

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

@@ -11,7 +11,6 @@ import {
 } from 'ontime-types';
 import { getCueCandidate } from 'ontime-utils';
 
-import { DataProvider } from '../../classes/data-provider/DataProvider.js';
 import { block as blockDef, delay as delayDef } from '../../models/eventsDefinition.js';
 import { sendRefetch } from '../../adapters/websocketAux.js';
 import { logger } from '../../classes/Logger.js';
@@ -26,7 +25,7 @@ function generateEvent(eventData: Partial<OntimeEvent> | Partial<OntimeDelay> |
   const id = cache.getUniqueId();
 
   if (isOntimeEvent(eventData)) {
-    return createEvent(eventData, getCueCandidate(DataProvider.getRundown(), eventData?.after)) as OntimeEvent;
+    return createEvent(eventData, getCueCandidate(cache.getPersistedRundown(), eventData?.after)) as OntimeEvent;
   }
 
   if (isOntimeDelay(eventData)) {
@@ -188,7 +187,7 @@ export function notifyChanges(options: { timer?: boolean | string[]; external?:
  * @return {array}
  */
 export function getRundown(): OntimeRundown {
-  return DataProvider.getRundown();
+  return cache.getPersistedRundown();
 }
 
 /**
@@ -196,7 +195,7 @@ export function getRundown(): OntimeRundown {
  * @return {array}
  */
 export function getTimedEvents(): OntimeEvent[] {
-  return DataProvider.getRundown().filter((event) => isOntimeEvent(event)) as OntimeEvent[];
+  return getRundown().filter((event) => isOntimeEvent(event)) as OntimeEvent[];
 }
 
 /**
@@ -204,7 +203,7 @@ export function getTimedEvents(): OntimeEvent[] {
  * @return {array}
  */
 export function getPlayableEvents(): OntimeEvent[] {
-  return DataProvider.getRundown().filter((event) => isOntimeEvent(event) && !event.skip) as OntimeEvent[];
+  return getRundown().filter((event) => isOntimeEvent(event) && !event.skip) as OntimeEvent[];
 }
 
 /**
@@ -288,7 +287,6 @@ export function findNext(currentEventId?: string): OntimeEvent | null {
 }
 
 export async function setRundown(rundown: OntimeRundown) {
-  await DataProvider.setRundown(rundown);
   cache.init(rundown);
   notifyChanges({ timer: true });
 }

apps/server/src/services/rundown-service/__tests__/rundownCache.test.ts

@@ -1,7 +1,174 @@
-import { EndAction, OntimeEvent, OntimeRundown, SupportedEvent, TimerType } from 'ontime-types';
+import {
+  EndAction,
+  OntimeBlock,
+  OntimeDelay,
+  OntimeEvent,
+  OntimeRundown,
+  SupportedEvent,
+  TimeStrategy,
+  TimerType,
+} from 'ontime-types';
 
 import { calculateRuntimeDelays, getDelayAt, calculateRuntimeDelaysFrom } from '../delayUtils.js';
-import { add, batchEdit, edit, remove, reorder, swap } from '../rundownCache.js';
+import { add, batchEdit, edit, generate, remove, reorder, swap } from '../rundownCache.js';
+
+describe('init() function', () => {
+  it('creates normalised versions of a given rundown', () => {
+    const testRundown: OntimeRundown = [
+      { type: SupportedEvent.Event, id: '1' } as OntimeEvent,
+      { type: SupportedEvent.Block, id: '2' } as OntimeBlock,
+      { type: SupportedEvent.Delay, id: '3' } as OntimeDelay,
+    ];
+
+    const initResult = generate(testRundown);
+    expect(initResult.order.length).toBe(3);
+    expect(initResult.order).toStrictEqual(['1', '2', '3']);
+    expect(initResult.rundown['1'].type).toBe(SupportedEvent.Event);
+    expect(initResult.rundown['2'].type).toBe(SupportedEvent.Block);
+    expect(initResult.rundown['3'].type).toBe(SupportedEvent.Delay);
+  });
+
+  it('calculates delays versions of a given rundown', () => {
+    const testRundown: OntimeRundown = [
+      { type: SupportedEvent.Delay, id: '1', duration: 100 } as OntimeDelay,
+      { type: SupportedEvent.Event, id: '2', timeStart: 1 } as OntimeEvent,
+      { type: SupportedEvent.Block, id: '3' } as OntimeBlock,
+      { type: SupportedEvent.Event, id: '4', timeStart: 2 } as OntimeEvent,
+    ];
+
+    const initResult = generate(testRundown);
+    expect(initResult.order.length).toBe(4);
+    expect((initResult.rundown['2'] as OntimeEvent).delay).toBe(100);
+    expect((initResult.rundown['4'] as OntimeEvent).delay).toBe(0);
+  });
+
+  it('links times across events', () => {
+    const testRundown: OntimeRundown = [
+      {
+        type: SupportedEvent.Event,
+        id: '1',
+        timeStart: 1,
+        duration: 1,
+        timeEnd: 2,
+        timeStrategy: TimeStrategy.LockEnd,
+      } as OntimeEvent,
+      {
+        type: SupportedEvent.Event,
+        id: '2',
+        timeStart: 11,
+        duration: 1,
+        timeEnd: 12,
+        linkStart: '1',
+        timeStrategy: TimeStrategy.LockEnd,
+      } as OntimeEvent,
+      { type: SupportedEvent.Block, id: 'block' } as OntimeBlock,
+      { type: SupportedEvent.Delay, id: 'delay' } as OntimeDelay,
+      {
+        type: SupportedEvent.Event,
+        id: '3',
+        timeStart: 21,
+        duration: 1,
+        timeEnd: 22,
+        linkStart: '2',
+        timeStrategy: TimeStrategy.LockEnd,
+      } as OntimeEvent,
+    ];
+
+    const initResult = generate(testRundown);
+    expect(initResult.order.length).toBe(5);
+    expect((initResult.rundown['2'] as OntimeEvent).timeStart).toBe(2);
+    expect((initResult.rundown['2'] as OntimeEvent).timeEnd).toBe(12);
+    expect((initResult.rundown['2'] as OntimeEvent).duration).toBe(10);
+
+    expect((initResult.rundown['3'] as OntimeEvent).timeStart).toBe(12);
+    expect((initResult.rundown['3'] as OntimeEvent).timeEnd).toBe(22);
+    expect((initResult.rundown['3'] as OntimeEvent).duration).toBe(10);
+
+    expect(initResult.links['1']).toBe('2');
+    expect(initResult.links['2']).toBe('3');
+  });
+
+  it('links times across events, reordered', () => {
+    const testRundown: OntimeRundown = [
+      { type: SupportedEvent.Event, id: '1', timeStart: 1, timeEnd: 2 } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '3', timeStart: 21, timeEnd: 22, linkStart: '2' } as OntimeEvent,
+      { type: SupportedEvent.Event, id: '2', timeStart: 11, timeEnd: 12, linkStart: '1' } as OntimeEvent,
+    ];
+
+    const initResult = generate(testRundown);
+    expect(initResult.order.length).toBe(3);
+    expect((initResult.rundown['3'] as OntimeEvent).timeStart).toBe(2);
+    expect(initResult.links['1']).toBe('3');
+    expect(initResult.links['3']).toBe('2');
+  });
+
+  it('handles updating event sequence', () => {
+    const testRundown: OntimeRundown = [
+      {
+        type: SupportedEvent.Event,
+        id: '97cc3e',
+        timeStart: 0,
+        timeEnd: 600000,
+        duration: 600000,
+        timeStrategy: TimeStrategy.LockDuration,
+        linkStart: null,
+      } as OntimeEvent,
+      {
+        type: SupportedEvent.Event,
+        id: 'e01948',
+        timeStart: 600000,
+        timeEnd: 601000,
+        duration: 85801000, // <------------- value out of sync
+        timeStrategy: TimeStrategy.LockEnd,
+        linkStart: '97cc3e',
+      } as OntimeEvent,
+      {
+        type: SupportedEvent.Event,
+        id: '25c1af',
+        timeStart: 100, // <------------- value out of sync
+        timeEnd: 602000,
+        duration: 0,
+        timeStrategy: TimeStrategy.LockEnd,
+        linkStart: 'e01948',
+      } as OntimeEvent,
+    ];
+
+    const initResult = generate(testRundown);
+    expect(initResult.rundown).toMatchObject({
+      '97cc3e': {
+        timeStart: 0,
+        timeEnd: 600000,
+        duration: 600000,
+        timeStrategy: 'lock-duration',
+        linkStart: null,
+      },
+      e01948: {
+        timeStart: 600000,
+        timeEnd: 601000,
+        duration: 1000,
+        timeStrategy: 'lock-end',
+        linkStart: '97cc3e',
+      },
+      '25c1af': {
+        timeStart: 601000,
+        timeEnd: 602000,
+        duration: 1000,
+        timeStrategy: 'lock-end',
+        linkStart: 'e01948',
+      },
+    });
+  });
+
+  it('deletes links if invalid', () => {
+    const testRundown: OntimeRundown = [
+      { type: SupportedEvent.Event, id: '1', timeStart: 1, linkStart: '10' } as OntimeEvent,
+    ];
+    const initResult = generate(testRundown);
+    expect(initResult.order.length).toBe(1);
+    expect((initResult.rundown['1'] as OntimeEvent).timeStart).toBe(1);
+    expect(Object.keys(initResult.links).length).toBe(0);
+  });
+});
 
 describe('add() mutation', () => {
   test('adds an event to the rundown', () => {
@@ -137,6 +304,8 @@ describe('calculateRuntimeDelays', () => {
         note: '',
         endAction: EndAction.None,
         timerType: TimerType.CountDown,
+        timeStrategy: TimeStrategy.LockEnd,
+        linkStart: null,
         timeStart: 600000,
         timeEnd: 1200000,
         duration: 600000,
@@ -172,6 +341,8 @@ describe('calculateRuntimeDelays', () => {
         note: '',
         endAction: EndAction.None,
         timerType: TimerType.CountDown,
+        timeStrategy: TimeStrategy.LockEnd,
+        linkStart: null,
         timeStart: 1200000,
         timeEnd: 1200000,
         duration: 0,
@@ -207,6 +378,8 @@ describe('calculateRuntimeDelays', () => {
         note: '',
         endAction: EndAction.None,
         timerType: TimerType.CountDown,
+        timeStrategy: TimeStrategy.LockEnd,
+        linkStart: null,
         timeStart: 600000,
         timeEnd: 1200000,
         duration: 600000,
@@ -242,6 +415,8 @@ describe('calculateRuntimeDelays', () => {
         note: '',
         endAction: EndAction.None,
         timerType: TimerType.CountDown,
+        timeStrategy: TimeStrategy.LockEnd,
+        linkStart: null,
         timeStart: 1200000,
         timeEnd: 1800000,
         duration: 600000,
@@ -286,6 +461,8 @@ describe('getDelayAt()', () => {
       note: '',
       endAction: EndAction.None,
       timerType: TimerType.CountDown,
+      timeStrategy: TimeStrategy.LockEnd,
+      linkStart: null,
       timeStart: 600000,
       timeEnd: 1200000,
       duration: 600000,
@@ -322,6 +499,8 @@ describe('getDelayAt()', () => {
       note: '',
       endAction: EndAction.None,
       timerType: TimerType.CountDown,
+      timeStrategy: TimeStrategy.LockEnd,
+      linkStart: null,
       timeStart: 1200000,
       timeEnd: 1200000,
       duration: 0,
@@ -358,6 +537,8 @@ describe('getDelayAt()', () => {
       note: '',
       endAction: EndAction.None,
       timerType: TimerType.CountDown,
+      timeStrategy: TimeStrategy.LockEnd,
+      linkStart: null,
       timeStart: 600000,
       timeEnd: 1200000,
       duration: 600000,
@@ -394,6 +575,8 @@ describe('getDelayAt()', () => {
       note: '',
       endAction: EndAction.None,
       timerType: TimerType.CountDown,
+      timeStrategy: TimeStrategy.LockEnd,
+      linkStart: null,
       timeStart: 1200000,
       timeEnd: 1800000,
       duration: 600000,
@@ -456,6 +639,8 @@ describe('calculateRuntimeDelaysFrom()', () => {
         note: '',
         endAction: EndAction.None,
         timerType: TimerType.CountDown,
+        timeStrategy: TimeStrategy.LockEnd,
+        linkStart: null,
         timeStart: 600000,
         timeEnd: 1200000,
         duration: 600000,
@@ -492,6 +677,8 @@ describe('calculateRuntimeDelaysFrom()', () => {
         note: '',
         endAction: EndAction.None,
         timerType: TimerType.CountDown,
+        timeStrategy: TimeStrategy.LockEnd,
+        linkStart: null,
         timeStart: 1200000,
         timeEnd: 1200000,
         duration: 0,
@@ -528,6 +715,8 @@ describe('calculateRuntimeDelaysFrom()', () => {
         note: '',
         endAction: EndAction.None,
         timerType: TimerType.CountDown,
+        timeStrategy: TimeStrategy.LockEnd,
+        linkStart: null,
         timeStart: 600000,
         timeEnd: 1200000,
         duration: 600000,
@@ -564,6 +753,8 @@ describe('calculateRuntimeDelaysFrom()', () => {
         note: '',
         endAction: EndAction.None,
         timerType: TimerType.CountDown,
+        timeStrategy: TimeStrategy.LockEnd,
+        linkStart: null,
         timeStart: 1200000,
         timeEnd: 1800000,
         duration: 600000,

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

@@ -6,80 +6,123 @@ import {
   OntimeRundown,
   OntimeRundownEntry,
 } from 'ontime-types';
-import { generateId, deleteAtIndex, insertAtIndex, reorderArray, swapEventData } from 'ontime-utils';
+import {
+  generateId,
+  deleteAtIndex,
+  insertAtIndex,
+  reorderArray,
+  swapEventData,
+  getLinkedTimes,
+  formatFromMillis,
+} from 'ontime-utils';
 
 import { DataProvider } from '../../classes/data-provider/DataProvider.js';
 import { createPatch } from '../../utils/parser.js';
 import { apply } from './delayUtils.js';
 
-type NormalisedRundown = Record<string, OntimeRundownEntry>;
+type EventID = string;
+type NormalisedRundown = Record<EventID, OntimeRundownEntry>;
+
+let persistedRundown: OntimeRundown = [];
+/** Utility function gets rundown from DataProvider */
+export const getPersistedRundown = (): OntimeRundown => persistedRundown;
 
 let rundown: NormalisedRundown = {};
-let order: string[] = [];
+let order: EventID[] = [];
 let revision = 0;
 let isStale = true;
 
-/**
- * Utility initialises cache
- * @param persistedRundown
- */
-export function init(persistedRundown: Readonly<OntimeRundown>) {
-  // we decided to try and re-write this dataset for every change
-  // instead of maintaining logic to update it
-  rundown = {};
-  order = [];
+let links: Record<EventID, EventID> = {};
 
-  let accumulatedDelay = 0;
-  for (let i = 0; i < persistedRundown.length; i++) {
-    const event = persistedRundown[i];
-
-    // calculate delays
-    if (isOntimeDelay(event)) {
-      accumulatedDelay += event.duration;
-    } else if (isOntimeBlock(event)) {
-      accumulatedDelay = 0;
-    } else if (isOntimeEvent(event)) {
-      event.delay = accumulatedDelay;
-    }
-
-    order.push(event.id);
-    rundown[event.id] = { ...event };
-  }
-  isStale = false;
+export async function init(initialRundown: OntimeRundown) {
+  persistedRundown = structuredClone(initialRundown);
+  generate();
+  await DataProvider.setRundown(persistedRundown);
 }
 
 /**
- * Returns an ID guaranteed to be unique
- * @returns
+ * Utility initialises cache
+ * @param rundown
  */
-export function getUniqueId(persistedRundown: Readonly<OntimeRundown> = getPersistedRundown()): string {
+export function generate(initialRundown: OntimeRundown = persistedRundown) {
+  // we decided to re-write this dataset for every change
+  // instead of maintaining logic to update it
+
+  function getLink(currentIndex: number): OntimeEvent | null {
+    // currently the link is the previous event
+    for (let i = currentIndex - 1; i >= 0; i--) {
+      const event = initialRundown[i];
+      if (isOntimeEvent(event)) {
+        return event;
+      }
+    }
+    return null;
+  }
+
+  rundown = {};
+  order = [];
+  links = {};
+
+  let accumulatedDelay = 0;
+  for (let i = 0; i < initialRundown.length; i++) {
+    const currentEvent = initialRundown[i];
+    let updatedEvent = { ...currentEvent };
+
+    // handle links
+    if (isOntimeEvent(updatedEvent)) {
+      if (updatedEvent.linkStart) {
+        const linkedEvent = getLink(i);
+        // link is always the previous event for now
+        if (linkedEvent) {
+          links[linkedEvent.id] = currentEvent.id;
+
+          const timePatch = getLinkedTimes(updatedEvent, linkedEvent);
+          updatedEvent = { ...updatedEvent, ...timePatch };
+        } else {
+          updatedEvent.linkStart = null;
+        }
+        // update the persisted event
+        initialRundown[i] = updatedEvent;
+      }
+    }
+
+    // calculate delays
+    if (isOntimeDelay(updatedEvent)) {
+      accumulatedDelay += updatedEvent.duration;
+    } else if (isOntimeBlock(updatedEvent)) {
+      accumulatedDelay = 0;
+    } else if (isOntimeEvent(updatedEvent)) {
+      updatedEvent.delay = accumulatedDelay;
+    }
+
+    order.push(updatedEvent.id);
+    rundown[updatedEvent.id] = { ...updatedEvent };
+  }
+
+  isStale = false;
+  return { rundown, order, links };
+}
+
+/** Returns an ID guaranteed to be unique */
+export function getUniqueId(): string {
+  if (isStale) {
+    generate();
+  }
   let id = '';
   do {
     id = generateId();
-  } while (!isIdUnique(persistedRundown, id));
+  } while (Object.hasOwn(rundown, id));
   return id;
 }
 
-export function isIdUnique(persistedRundown: Readonly<OntimeRundown>, eventId: string) {
-  if (isStale) {
-    init(persistedRundown);
-  }
-  return !Object.hasOwn(rundown, eventId);
-}
-
+/** Returns index of an event with a given id */
 export function getIndexOf(eventId: string) {
   if (isStale) {
-    init(getPersistedRundown());
+    generate();
   }
   return order.indexOf(eventId);
 }
 
-/**
- * Utility function gets rundown from DataProvider
- * @returns {OntimeRundown}
- */
-export const getPersistedRundown = (): OntimeRundown => DataProvider.getRundown();
-
 type RundownCache = {
   rundown: NormalisedRundown;
   order: string[];
@@ -93,7 +136,7 @@ type RundownCache = {
 export function get(): Readonly<RundownCache> {
   if (isStale) {
     console.time('rundownCache__init');
-    init(getPersistedRundown());
+    generate();
     console.timeEnd('rundownCache__init');
   }
   return {
@@ -117,21 +160,25 @@ type MutatingFn<T extends object> = (params: MutationParams<T>) => MutatingRetur
  */
 export function mutateCache<T extends object>(mutation: MutatingFn<T>) {
   async function scopedMutation(params: T) {
-    const persistedRundown = getPersistedRundown();
     const { newEvent, newRundown } = mutation({ ...params, persistedRundown });
 
     revision = revision + 1;
     isStale = true;
+    persistedRundown = newRundown;
 
-    DataProvider.setRundown(newRundown);
-    // schedule the update to the next tick
-
-    process.nextTick(() => {
+    // schedule a non priority cache update
+    setImmediate(() => {
       console.time('rundownCache__init');
-      init(newRundown);
+      generate();
       console.timeEnd('rundownCache__init');
     });
 
+    // TODO: should we trottle this?
+    // defer writing to the database
+    setImmediate(() => {
+      DataProvider.setRundown(persistedRundown);
+    });
+
     // TODO: could we return a patch object?
     return { newEvent };
   }
@@ -186,8 +233,12 @@ export function edit({ persistedRundown, eventId, patch }: EditArgs): Required<M
     throw new Error('Invalid event type');
   }
 
+  // @ts-expect-error -- testing
+  console.log('patch', formatFromMillis(patch?.timeStart ?? 0, 'HH:mm:ss'));
+
   const eventInMemory = persistedRundown[indexAt];
   const newEvent = makeEvent(eventInMemory, patch);
+
   const newRundown = [...persistedRundown];
   newRundown[indexAt] = newEvent;