V3 (#657)

* refactor: cleanup routes

* style: smaller base font

* chore: upgrade dependencies

* chore: lock node version to electron

* refactor: pass HTTP to integration controller (#652)

* refactor: deprecate onair control

* refactor: remove playback router

* Several project files user folder (#617)

* chore: automated screenshots (#667)

* feat: app settings (#658)

* refactor: remove deprecated event data (#674)

* Studio clock (#663)

---------

Co-authored-by: Carlos Valente <carlosvalente@pm.me>

* Feat: reorder events with alt+ctrl + arrow up/down (#645)

* Warning and danger per event (#677)

---------

Co-authored-by: Fabian Posenau <fabian@fphome.de>

* refactor: stabilise actionHandler (#683)

Co-authored-by: Fabian Posenau <fabian@fphome.de>

* improvement: hide seconds (#675)

* wip: overview (#688)

* fix: focus cursor (#695)

* refactor: update lower third (#665)

* Refactor/time formatting (#696)

---------

Co-authored-by: Carlos Valente <34649812+cpvalente@users.noreply.github.com>
Co-authored-by: Carlos Valente <carlosvalente@pm.me>

* feat: multiple selection (#703)

---------

Co-authored-by: asharonbaltazar <asharonbaltazar@outlook.com>
Co-authored-by: Alex <ac@omnivox.dk>

* fix: test - go to `Edit mode` befor tying to click `Event options` button (#708)

* refactor: runtime service (#715)

* fix: issue with loosing cursor position on message (#719)

* remove info panel (#721)

* Event editor continue (#722)

* update API - part  (#709)

---------

Co-authored-by: Carlos Valente <34649812+cpvalente@users.noreply.github.com>
Co-authored-by: Carlos Valente <carlosvalente@pm.me>

* refactor: update timers (#729)

* feat: many timers (#706)

---------

Co-authored-by: arc-alex <ac@omnivox.dk>

* refactor: excel cleanup (#734)

* refactor: allow import of blocks and skip import (#735)

* Project manager (#697)

* refactor: UI for linking events (#763)

* upgraded pipeline actions (#777)

* Over under (#771)

* custom fields (#744)


---------

Co-authored-by: Carlos Valente <carlosvalente@pm.me>

* Sheets settings (#774)

---------

Co-authored-by: arc-alex <ac@omnivox.dk>

* style: tweaks to lower thirds (#785)

* refactor: delays account for gaps (#784)

* refactor: partial state updates (#780)

* feat: generate crash report (#787)

* Sheet use limited input device auth flow (#782)

---------

Co-authored-by: cv <34649812+cpvalente@users.noreply.github.com>
Co-authored-by: Carlos Valente <carlosvalente@pm.me>

* Custom fields views (#789)

* refactor: deprecate presenter and subtitle (#795)

* refactor: organise API around resources (#798)

---------

Co-authored-by: Bianca Procopio <biancahprocopio@gmail.com>

* Time to end (#804)

* Skip fixes (#805)

* fix: onair derives from playback

* Param nav (#822)

---------

Co-authored-by: Alex Christoffer Rasmussen <ac@omnivox.dk>

* refactor: download files from interface (#831)

* Quick options (#814)

* End pause (#832)

* chore: bump node version in docker (#834)

* refactor: follow in run mode (#840)

* fix: uncaught error in http integration (#837)

* Apply project (#843)

Co-authored-by: Matteo Gheza <matteo.gheza07@gmail.com>
Co-authored-by: Ary <arylmoraesn@gmail.com>
Co-authored-by: Alex Christoffer Rasmussen <ac@omnivox.dk>
Co-authored-by: Fabian Posenau <19673098+kellhogs@users.noreply.github.com>
Co-authored-by: Fabian Posenau <fabian@fphome.de>
Co-authored-by: Alex Rohleder <alexrohleder96@gmail.com>
Co-authored-by: asharonbaltazar <asharonbaltazar@outlook.com>
Co-authored-by: Bianca Procopio <biancahprocopio@gmail.com>
Co-authored-by: Fabian Posenau <fabianpos99+github@gmail.com>

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

@@ -0,0 +1,495 @@
+import {
+  CustomField,
+  CustomFieldLabel,
+  CustomFields,
+  isOntimeDelay,
+  isOntimeEvent,
+  MaybeNumber,
+  OntimeEvent,
+  OntimeRundown,
+  OntimeRundownEntry,
+} from 'ontime-types';
+import { generateId, deleteAtIndex, insertAtIndex, reorderArray, swapEventData } from 'ontime-utils';
+
+import { DataProvider } from '../../classes/data-provider/DataProvider.js';
+import { createPatch } from '../../utils/parser.js';
+import { getTotalDuration } from '../timerUtils.js';
+import { apply } from './delayUtils.js';
+import { handleCustomField, handleLink, hasChanges, isDataStale } from './rundownCacheUtils.js';
+
+type EventID = string;
+type NormalisedRundown = Record<EventID, OntimeRundownEntry>;
+
+let persistedRundown: OntimeRundown = [];
+let persistedCustomFields: CustomFields = {};
+
+/** Utility function gets to expose data */
+export const getPersistedRundown = (): OntimeRundown => persistedRundown;
+export const getCustomFields = (): CustomFields => persistedCustomFields;
+
+let rundown: NormalisedRundown = {};
+let order: EventID[] = [];
+let revision = 0;
+let isStale = true;
+let totalDelay = 0;
+let totalDuration = 0;
+let firstStart: MaybeNumber = null;
+let lastEnd: MaybeNumber = null;
+
+let links: Record<EventID, EventID> = {};
+
+/**
+ * Object that contains renamings to custom fields
+ * Used to rename the custom fields in the events
+ * @example
+ * {
+ *  oldLabel: newLabel
+ *  lighting: lx
+ * }
+ */
+const customFieldChangelog = {};
+
+/**
+ * Keep track of which custom fields are used.
+ * This will be handy for when we delete custom fields
+ */
+let assignedCustomFields: Record<CustomFieldLabel, EventID[]> = {};
+
+export async function init(initialRundown: Readonly<OntimeRundown>, customFields: Readonly<CustomFields>) {
+  persistedRundown = structuredClone(initialRundown) as OntimeRundown;
+  persistedCustomFields = structuredClone(customFields);
+  generate();
+  await DataProvider.setRundown(persistedRundown);
+  await DataProvider.setCustomFields(customFields);
+}
+
+/**
+ * Utility initialises cache
+ * @param rundown
+ */
+export function generate(
+  initialRundown: OntimeRundown = persistedRundown,
+  customFields: CustomFields = persistedCustomFields,
+) {
+  // we decided to re-write this dataset for every change
+  // instead of maintaining logic to update it
+
+  assignedCustomFields = {};
+  rundown = {};
+  order = [];
+  links = {};
+  firstStart = null;
+  lastEnd = null;
+
+  let accumulatedDelay = 0;
+  let daySpan = 0;
+  let previousEnd: MaybeNumber = null;
+
+  for (let i = 0; i < initialRundown.length; i++) {
+    const currentEvent = initialRundown[i];
+    const updatedEvent = { ...currentEvent };
+
+    if (isOntimeEvent(updatedEvent)) {
+      // 1. handle links
+      handleLink(i, initialRundown, updatedEvent, links);
+
+      // 2. handle custom fields
+      handleCustomField(customFields, customFieldChangelog, updatedEvent, assignedCustomFields);
+
+      // update the persisted event
+      initialRundown[i] = updatedEvent;
+
+      // update rundown duration
+      if (firstStart === null) {
+        firstStart = updatedEvent.timeStart;
+      }
+      lastEnd = updatedEvent.timeEnd;
+
+      // check if we go over midnight, account for eventual gaps
+      const gapOverMidnight = previousEnd !== null && previousEnd > updatedEvent.timeStart;
+      const durationOverMidnight = updatedEvent.timeStart > updatedEvent.timeEnd;
+      if (gapOverMidnight || durationOverMidnight) {
+        daySpan++;
+      }
+    }
+
+    // calculate delays
+    // !!! this must happen after handling the links
+    if (isOntimeDelay(updatedEvent)) {
+      accumulatedDelay += updatedEvent.duration;
+    } else if (isOntimeEvent(updatedEvent)) {
+      const eventStart = updatedEvent.timeStart;
+
+      // we only affect positive delays (time forwards)
+      if (accumulatedDelay > 0 && previousEnd) {
+        const gap = Math.max(eventStart - previousEnd, 0);
+        accumulatedDelay = Math.max(accumulatedDelay - gap, 0);
+      }
+      updatedEvent.delay = accumulatedDelay;
+      previousEnd = updatedEvent.timeEnd;
+    }
+
+    order.push(updatedEvent.id);
+    rundown[updatedEvent.id] = { ...updatedEvent };
+  }
+
+  isStale = false;
+  totalDelay = accumulatedDelay;
+  if (lastEnd !== null && firstStart !== null) {
+    totalDuration = getTotalDuration(firstStart, lastEnd, daySpan);
+  }
+
+  return { rundown, order, links, totalDelay, totalDuration, assignedCustomProperties: assignedCustomFields };
+}
+
+/** Returns an ID guaranteed to be unique */
+export function getUniqueId(): string {
+  if (isStale) {
+    generate();
+  }
+  let id = '';
+  do {
+    id = generateId();
+  } while (Object.hasOwn(rundown, id));
+  return id;
+}
+
+/** Returns index of an event with a given id */
+export function getIndexOf(eventId: string) {
+  if (isStale) {
+    generate();
+  }
+  return order.indexOf(eventId);
+}
+
+type RundownCache = {
+  rundown: NormalisedRundown;
+  order: string[];
+  revision: number;
+  totalDelay: number;
+  totalDuration: number;
+};
+
+/**
+ * Returns cached data
+ * @returns {RundownCache}
+ */
+export function get(): Readonly<RundownCache> {
+  if (isStale) {
+    console.time('rundownCache__init');
+    generate();
+    console.timeEnd('rundownCache__init');
+  }
+  return {
+    rundown,
+    order,
+    revision,
+    totalDelay,
+    totalDuration,
+  };
+}
+
+/**
+ * Returns calculated metadata from rundown
+ */
+export function getMetadata() {
+  if (isStale) {
+    console.time('rundownCache__init');
+    generate();
+    console.timeEnd('rundownCache__init');
+  }
+
+  return {
+    firstStart,
+    lastEnd,
+    totalDelay,
+    totalDuration,
+  };
+}
+
+type CommonParams = { persistedRundown: OntimeRundown };
+type MutationParams<T> = T & CommonParams;
+type MutatingReturn = {
+  newRundown: OntimeRundown;
+  newEvent?: OntimeRundownEntry;
+  didMutate: boolean;
+};
+type MutatingFn<T extends object> = (params: MutationParams<T>) => MutatingReturn;
+
+/**
+ * Decorators injects data into mutation
+ * @param mutation
+ * @returns
+ */
+export function mutateCache<T extends object>(mutation: MutatingFn<T>) {
+  async function scopedMutation(params: T) {
+    /**
+     * Marking the data set as stale
+     * doing it before calling the mutation, gives the function a chance
+     * to prevent recalculation by setting stale = false
+     */
+    isStale = true;
+
+    const { newEvent, newRundown, didMutate } = mutation({ ...params, persistedRundown });
+
+    revision = revision + 1;
+    persistedRundown = newRundown;
+
+    // schedule a non priority cache update
+    setImmediate(() => {
+      console.time('rundownCache__init');
+      get();
+      console.timeEnd('rundownCache__init');
+    });
+
+    // defer writing to the database
+    setImmediate(() => {
+      DataProvider.setRundown(persistedRundown);
+    });
+
+    return { newEvent, newRundown, didMutate };
+  }
+
+  return scopedMutation;
+}
+
+type AddArgs = MutationParams<{ atIndex: number; event: OntimeRundownEntry }>;
+
+export function add({ persistedRundown, atIndex, event }: AddArgs): Required<MutatingReturn> {
+  const newEvent: OntimeRundownEntry = { ...event };
+  const newRundown = insertAtIndex(atIndex, newEvent, persistedRundown);
+
+  return { newRundown, newEvent, didMutate: true };
+}
+
+type RemoveArgs = MutationParams<{ eventId: string }>;
+
+export function remove({ persistedRundown, eventId }: RemoveArgs): MutatingReturn {
+  const atIndex = persistedRundown.findIndex((event) => event.id === eventId);
+  const newRundown = deleteAtIndex(atIndex, persistedRundown);
+
+  return { newRundown, didMutate: atIndex !== -1 };
+}
+
+export function removeAll(): MutatingReturn {
+  return { newRundown: [], didMutate: true };
+}
+
+/**
+ * Utility function for patching events
+ * @param eventFromRundown
+ * @param patch
+ * @returns
+ */
+function makeEvent(eventFromRundown: OntimeRundownEntry, patch: Partial<OntimeRundownEntry>): OntimeRundownEntry {
+  if (isOntimeEvent(eventFromRundown)) {
+    const newEvent = createPatch(eventFromRundown, patch as OntimeEvent);
+    newEvent.revision++;
+    return newEvent;
+  }
+  // TODO: exhaustive check
+  return { ...eventFromRundown, ...patch } as OntimeRundownEntry;
+}
+
+type EditArgs = MutationParams<{ eventId: string; patch: Partial<OntimeRundownEntry> }>;
+
+export function edit({ persistedRundown, eventId, patch }: EditArgs): Required<MutatingReturn> {
+  const indexAt = persistedRundown.findIndex((event) => event.id === eventId);
+
+  if (indexAt < 0) {
+    throw new Error('Event not found');
+  }
+
+  if (patch?.type && persistedRundown[indexAt].type !== patch.type) {
+    throw new Error('Invalid event type');
+  }
+
+  const eventInMemory = persistedRundown[indexAt];
+  if (!hasChanges(eventInMemory, patch)) {
+    isStale = false;
+    return { newRundown: persistedRundown, newEvent: eventInMemory, didMutate: false };
+  }
+
+  const newEvent = makeEvent(eventInMemory, patch);
+
+  const newRundown = [...persistedRundown];
+  newRundown[indexAt] = newEvent;
+
+  // check whether the data warrants recalculation of cache
+  const makeStale = isDataStale(patch);
+
+  if (!makeStale) {
+    rundown[newEvent.id] = newEvent;
+  }
+
+  isStale = makeStale;
+  return { newRundown, newEvent, didMutate: true };
+}
+
+type BatchEditArgs = MutationParams<{ eventIds: string[]; patch: Partial<OntimeRundownEntry> }>;
+
+export function batchEdit({ persistedRundown, eventIds, patch }: BatchEditArgs): MutatingReturn {
+  const ids = new Set(eventIds);
+
+  const newRundown = [];
+  for (let i = 0; i < persistedRundown.length; i++) {
+    if (ids.has(persistedRundown[i].id)) {
+      if (patch?.type && persistedRundown[i].type !== patch.type) {
+        continue;
+      }
+      const newEvent = makeEvent(persistedRundown[i], patch);
+      newRundown.push(newEvent);
+    } else {
+      newRundown.push(persistedRundown[i]);
+    }
+  }
+  return { newRundown, didMutate: true };
+}
+
+type ReorderArgs = MutationParams<{ eventId: string; from: number; to: number }>;
+
+export function reorder({ persistedRundown, eventId, from, to }: ReorderArgs): Required<MutatingReturn> {
+  const event = persistedRundown[from];
+  if (!event || eventId !== event.id) {
+    throw new Error('Event not found');
+  }
+
+  const newRundown = reorderArray(persistedRundown, from, to);
+  for (let i = from; i <= to; i++) {
+    const event = newRundown.at(i);
+    if (isOntimeEvent(event)) {
+      event.revision += 1;
+    }
+  }
+  return { newRundown, newEvent: newRundown.at(from) as OntimeRundownEntry, didMutate: true };
+}
+
+type ApplyDelayArgs = MutationParams<{ eventId: string }>;
+
+export function applyDelay({ persistedRundown, eventId }: ApplyDelayArgs): MutatingReturn {
+  const newRundown = apply(eventId, persistedRundown);
+  return { newRundown, didMutate: true };
+}
+
+type SwapArgs = MutationParams<{ fromId: string; toId: string }>;
+
+export function swap({ persistedRundown, fromId, toId }: SwapArgs): MutatingReturn {
+  const indexA = persistedRundown.findIndex((event) => event.id === fromId);
+  const eventA = persistedRundown.at(indexA);
+
+  const indexB = persistedRundown.findIndex((event) => event.id === toId);
+  const eventB = persistedRundown.at(indexB);
+
+  if (!isOntimeEvent(eventA) || !isOntimeEvent(eventB)) {
+    throw new Error('Swap only available for OntimeEvents');
+  }
+
+  const { newA, newB } = swapEventData(eventA, eventB);
+  const newRundown = [...persistedRundown];
+
+  newRundown[indexA] = newA;
+  (newRundown[indexA] as OntimeEvent).revision += 1;
+  newRundown[indexB] = newB;
+  (newRundown[indexB] as OntimeEvent).revision += 1;
+
+  return { newRundown, didMutate: true };
+}
+
+/**
+ * Invalidates service cache if a custom field is used
+ * @param label
+ */
+function invalidateIfUsed(label: CustomFieldLabel) {
+  if (label in assignedCustomFields) {
+    isStale = true;
+  }
+  // if the field was in use, we mark the cache as stale
+  if (label in assignedCustomFields) {
+    isStale = true;
+  }
+  // ... and schedule a cache update
+  // schedule a non priority cache update
+  setImmediate(() => {
+    console.time('rundownCache__init');
+    generate();
+    console.timeEnd('rundownCache__init');
+  });
+}
+
+/**
+ * Scheduløes a non priority custom field persist
+ * @param persistedCustomFields
+ */
+function scheduleCustomFieldPersist(persistedCustomFields: CustomFields) {
+  setImmediate(() => {
+    DataProvider.setCustomFields(persistedCustomFields);
+  });
+}
+
+/**
+ * Sanitises and creates a custom field in the database
+ * @param field
+ * @returns
+ */
+export const createCustomField = async (field: CustomField) => {
+  const { label, type, colour } = field;
+  const key = label.toLowerCase();
+  // check if label already exists
+  const alreadyExists = Object.hasOwn(persistedCustomFields, key);
+
+  if (alreadyExists) {
+    throw new Error('Label already exists');
+  }
+
+  // update object and persist
+  persistedCustomFields[key] = { label, type, colour };
+
+  scheduleCustomFieldPersist(persistedCustomFields);
+
+  return persistedCustomFields;
+};
+
+/**
+ * Edits an existing custom field in the database
+ * @param key
+ * @param newField
+ * @returns
+ */
+export const editCustomField = async (key: string, newField: Partial<CustomField>) => {
+  if (!(key in persistedCustomFields)) {
+    throw new Error('Could not find label');
+  }
+
+  const existingField = persistedCustomFields[key];
+  if (existingField.type !== newField.type) {
+    throw new Error('Change of field type is not allowed');
+  }
+
+  const newKey = newField.label.toLowerCase();
+  persistedCustomFields[newKey] = { ...existingField, ...newField };
+
+  if (key !== newKey) {
+    delete persistedCustomFields[key];
+    customFieldChangelog[key] = newKey;
+  }
+
+  scheduleCustomFieldPersist(persistedCustomFields);
+  invalidateIfUsed(key);
+
+  return persistedCustomFields;
+};
+
+/**
+ * Deletes a custom field from the database
+ * @param label
+ */
+export const removeCustomField = async (label: string) => {
+  if (label in persistedCustomFields) {
+    delete persistedCustomFields[label];
+  }
+
+  scheduleCustomFieldPersist(persistedCustomFields);
+  invalidateIfUsed(label);
+
+  return persistedCustomFields;
+};