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/api-integration/integration.controller.ts

@@ -0,0 +1,256 @@
+import { DeepPartial, MessageState, OntimeEvent, SimpleDirection, SimplePlayback } from 'ontime-types';
+
+import { ONTIME_VERSION } from '../ONTIME_VERSION.js';
+import { extraTimerService } from '../services/extra-timer-service/ExtraTimerService.js';
+import { messageService } from '../services/message-service/MessageService.js';
+import { validateMessage, validateTimerMessage } from '../services/message-service/messageUtils.js';
+import { runtimeService } from '../services/runtime-service/RuntimeService.js';
+import { eventStore } from '../stores/EventStore.js';
+import * as assert from '../utils/assert.js';
+import { isEmptyObject } from '../utils/parserUtils.js';
+import { parseProperty, updateEvent } from './integration.utils.js';
+
+export function dispatchFromAdapter(type: string, payload: unknown, _source?: 'osc' | 'ws' | 'http') {
+  const action = type.toLowerCase();
+  const handler = actionHandlers[action];
+  if (handler) {
+    return handler(payload);
+  } else {
+    throw new Error(`Unhandled message ${type}`);
+  }
+}
+
+type ActionHandler = (payload: unknown) => { payload: unknown };
+
+const actionHandlers: Record<string, ActionHandler> = {
+  /* General */
+  version: () => ({ payload: ONTIME_VERSION }),
+  poll: () => ({
+    payload: eventStore.poll(),
+  }),
+  change: (payload) => {
+    assert.isObject(payload);
+    if (Object.keys(payload).length === 0) {
+      throw new Error('Payload is empty');
+    }
+
+    const id = Object.keys(payload).at(0);
+    if (!id) {
+      throw new Error('Missing Event ID');
+    }
+
+    const data = payload[id as keyof typeof payload];
+    const patchEvent: Partial<OntimeEvent> & { id: string } = { id };
+
+    Object.entries(data).forEach(([property, value]) => {
+      if (typeof property !== 'string' || value === undefined) {
+        throw new Error('Invalid property or value');
+      }
+      const newObjectProperty = parseProperty(property, value);
+
+      if (patchEvent.custom && newObjectProperty.custom) {
+        Object.assign(patchEvent.custom, newObjectProperty.custom);
+      } else {
+        Object.assign(patchEvent, newObjectProperty);
+      }
+    });
+
+    updateEvent(patchEvent);
+    Object.assign(patchEvent);
+
+    return { payload: 'success' };
+  },
+  /* Message Service */
+  message: (payload) => {
+    assert.isObject(payload);
+
+    const patch: DeepPartial<MessageState> = {
+      timer: 'timer' in payload ? validateTimerMessage(payload.timer) : undefined,
+      public: 'public' in payload ? validateMessage(payload.public) : undefined,
+      lower: 'lower' in payload ? validateMessage(payload.lower) : undefined,
+      external: 'external' in payload ? validateMessage(payload.external) : undefined,
+    };
+
+    const newMessage = messageService.patch(patch);
+    return { payload: newMessage };
+  },
+  /* Playback */
+  start: (payload) => {
+    if (payload === undefined) {
+      return successPayloadOrError(runtimeService.start(), 'Uable to start');
+    }
+
+    if (payload && typeof payload === 'object') {
+      if ('index' in payload) {
+        const eventIndex = numberOrError(payload.index);
+        if (eventIndex <= 0) {
+          throw new Error(`Event index out of range ${eventIndex}`);
+        }
+        // Indexes in frontend are 1 based
+        return successPayloadOrError(
+          runtimeService.startByIndex(eventIndex - 1),
+          `Event index not recognised or out of range ${eventIndex}`,
+        );
+      }
+
+      if ('id' in payload) {
+        assert.isString(payload.id);
+        return successPayloadOrError(runtimeService.startById(payload.id), `Unable to start ID: ${payload.id}`);
+      }
+
+      if ('cue' in payload) {
+        const cue = extractCue(payload.cue);
+        return successPayloadOrError(runtimeService.startByCue(cue), `Unable to start CUE: ${cue}`);
+      }
+    }
+
+    if (payload === 'next') {
+      return successPayloadOrError(runtimeService.startNext(), 'Unable to start next event');
+    }
+
+    if (payload === 'previous') {
+      return successPayloadOrError(runtimeService.startPrevious(), 'Unable to start previous event');
+    }
+
+    throw new Error('No matching start function');
+  },
+  pause: () => {
+    runtimeService.pause();
+    return { payload: 'success' };
+  },
+  stop: () => {
+    runtimeService.stop();
+    return { payload: 'success' };
+  },
+  reload: () => {
+    runtimeService.reload();
+    return { payload: 'success' };
+  },
+  roll: () => {
+    runtimeService.roll();
+    return { payload: 'success' };
+  },
+  load: (payload) => {
+    if (payload && typeof payload === 'object') {
+      if ('index' in payload) {
+        const eventIndex = numberOrError(payload.index);
+        if (eventIndex <= 0) {
+          throw new Error(`Event index out of range ${eventIndex}`);
+        }
+        // Indexes in frontend are 1 based
+        return successPayloadOrError(
+          runtimeService.loadByIndex(eventIndex - 1),
+          `Event index not recognised or out of range ${eventIndex}`,
+        );
+      }
+
+      if ('id' in payload) {
+        assert.isString(payload.id);
+        return successPayloadOrError(runtimeService.loadById(payload.id), `Unable to load ID: ${payload.id}`);
+      }
+
+      if ('cue' in payload) {
+        const cue = extractCue(payload.cue);
+        return successPayloadOrError(runtimeService.loadByCue(cue), `Unable to load CUE: ${cue}`);
+      }
+    }
+
+    if (payload === 'next') {
+      return successPayloadOrError(runtimeService.loadNext(), 'Unable to load next event');
+    }
+
+    if (payload === 'previous') {
+      return successPayloadOrError(runtimeService.loadPrevious(), 'Unable to load previous event');
+    }
+    throw new Error('No matching method provided');
+  },
+  addtime: (payload) => {
+    let time = 0;
+    if (payload && typeof payload === 'object') {
+      if ('add' in payload) {
+        time = numberOrError(payload.add);
+      } else if ('remove' in payload) {
+        time = numberOrError(payload.remove) * -1;
+      }
+    } else {
+      time = numberOrError(payload);
+    }
+    assert.isNumber(time);
+    if (time === 0) {
+      return { payload: 'success' };
+    }
+    runtimeService.addTime(time * 1000); //frontend is seconds based
+    return { payload: 'success' };
+  },
+  /* Extra timers */
+  auxtimer: (payload) => {
+    assert.isObject(payload);
+    if (!('1' in payload)) {
+      throw new Error('Invalid auxtimer index');
+    }
+    const command = payload['1'];
+    if (typeof command === 'string') {
+      if (command === SimplePlayback.Start) {
+        const reply = extraTimerService.start();
+        return { payload: reply };
+      }
+      if (command === SimplePlayback.Pause) {
+        const reply = extraTimerService.pause();
+        return { payload: reply };
+      }
+      if (command === SimplePlayback.Stop) {
+        const reply = extraTimerService.stop();
+        return { payload: reply };
+      }
+    } else if (command && typeof command === 'object') {
+      const reply = { payload: {} };
+      if ('duration' in command) {
+        const time = numberOrError(command.duration);
+        reply.payload = extraTimerService.setTime(time * 1000); //frontend is seconds based
+      }
+      if ('direction' in command) {
+        if (command.direction === SimpleDirection.CountUp || command.direction === SimpleDirection.CountDown) {
+          reply.payload = extraTimerService.setDirection(command.direction);
+        } else {
+          throw new Error('Invalid direction payload');
+        }
+      }
+      if (!isEmptyObject(reply.payload)) {
+        return reply;
+      }
+    }
+    throw new Error('No matching method provided');
+  },
+};
+
+/**
+ * Returns a value of type number, converting if necessary
+ * Otherwise throws
+ * @param value
+ * @returns number
+ * @throws
+ */
+function numberOrError(value: unknown) {
+  const converted = Number(value);
+  if (isNaN(converted)) {
+    throw new Error('Payload is not a valid number');
+  }
+  return converted;
+}
+
+function extractCue(value: unknown): string {
+  if (typeof value === 'number') {
+    return String(value);
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  throw new Error('Payload is not a valid string or number');
+}
+
+function successPayloadOrError(success: boolean, error: string) {
+  if (!success) {
+    throw new Error(error);
+  }
+  return { payload: 'success' };
+}