V2 integration (#293)

* feat: integrations and lifecycles * refactor: prevent issues with start order
2026-08-14 11:53:49 +00:00 · 2023-02-23 20:22:38 +01:00
parent d8a84ac88d
commit 70cc071425
61 changed files with 1510 additions and 687 deletions
@@ -0,0 +1,170 @@
+/**
+ * Class Event Provider is a mediator for handling the local db
+ * and adds logic specific to ontime data
+ */
+import { data, db } from '../../modules/loadDb.js';
+import { safeMerge } from './DataProvider.utils.js';
+
+export class DataProvider {
+  static getData() {
+    return data;
+  }
+
+  static async setEventData(newData) {
+    data.event = { ...data.event, ...newData };
+    await this.persist();
+    return data.event;
+  }
+
+  static getEventData() {
+    return data.event;
+  }
+
+  static async setRundown(newData) {
+    data.rundown = [...newData];
+    await this.persist();
+  }
+
+  static getEventById(eventId) {
+    return data.rundown.find((e) => e.id === eventId);
+  }
+
+  static async updateEventById(eventId, newData) {
+    const eventIndex = data.rundown.findIndex((e) => e.id === eventId);
+    const persistedEvent = data.rundown[eventIndex];
+    const newEvent = { ...persistedEvent, ...newData };
+    newEvent.revision++;
+    data.rundown[eventIndex] = newEvent;
+    await this.persist();
+    return data.rundown[eventIndex];
+  }
+
+  static async deleteEvent(eventId) {
+    // @ts-expect-error -- this will go away once we type db
+    data.rundown = Array.from(data.rundown).filter((e) => e.id !== eventId);
+    await this.persist();
+  }
+
+  static getRundownLength() {
+    return data.rundown.length;
+  }
+
+  static async clearRundown() {
+    data.rundown = [];
+    // @ts-expect-error -- not sure how to type, this is library side
+    await db.write();
+  }
+
+  /**
+   * Insets an event after a given index
+   * @param entry
+   * @param index
+   * @return {Promise<void>}
+   */
+  static async insertEventAt(entry, index) {
+    // get events
+    const events = DataProvider.getRundown();
+    const count = events.length;
+    const order = entry.order;
+
+    // Remove order field from object
+    delete entry.order;
+
+    // Insert at beginning
+    if (order === 0) {
+      events.unshift(entry);
+    }
+
+    // insert at end
+    else if (order >= count) {
+      events.push(entry);
+    }
+
+    // insert in the middle
+    else {
+      events.splice(index, 0, entry);
+    }
+
+    // save events
+    await DataProvider.setRundown(events);
+  }
+
+  /**
+   * @description Inserts an entry after an element with given ID
+   * @param entry
+   * @param id
+   * @return {Promise<void>}
+   */
+  static async insertEventAfterId(entry, id) {
+    const index = [...data.rundown].findIndex((event) => event.id === id);
+    // eslint-disable-next-line no-unused-vars,@typescript-eslint/no-unused-vars -- we are just getting rid of after parameter
+    const { after, ...sanitisedEvent } = entry;
+    await DataProvider.insertEventAt(sanitisedEvent, index + 1);
+  }
+
+  static getSettings() {
+    return data.settings;
+  }
+
+  static async setSettings(newData) {
+    data.settings = { ...newData };
+    await this.persist();
+  }
+
+  static getOsc() {
+    return data.osc;
+  }
+
+  static getAliases() {
+    return data.aliases;
+  }
+
+  static async setAliases(newData) {
+    data.aliases = newData;
+    await this.persist();
+  }
+
+  static getUserFields() {
+    return { ...data.userFields };
+  }
+
+  static getViews() {
+    return { ...data.views };
+  }
+
+  static async setViews(newData) {
+    data.views = { ...newData };
+    await this.persist();
+  }
+
+  static async setUserFields(newData) {
+    data.userFields = { ...newData };
+    await this.persist();
+  }
+
+  static async setOsc(newData) {
+    data.osc = { ...newData };
+    await this.persist();
+  }
+
+  static getRundown() {
+    return [...data.rundown];
+  }
+
+  static async persist() {
+    // @ts-expect-error -- not sure how to type, this is library side
+    await db.write();
+  }
+
+  static async mergeIntoData(newData) {
+    const mergedData = safeMerge(data, newData);
+    data.event = mergedData.event;
+    data.settings = mergedData.settings;
+    data.osc = mergedData.osc;
+    data.http = mergedData.http;
+    data.aliases = mergedData.aliases;
+    data.userFields = mergedData.userFields;
+    data.rundown = mergedData.rundown;
+    await this.persist();
+  }
+}