chore: add demo project

apps/server/src/api-data/db/__tests__/db.parser.test.ts

@@ -1,5 +1,7 @@
 /* eslint-disable no-console --  we are mocking the console */
 
+import { SupportedEntry } from 'ontime-types';
+
 import { demoDb } from '../../../models/demoProject.js';
 
 import { parseDatabaseModel } from '../db.parser.js';
@@ -22,9 +24,17 @@ describe('test parseDatabaseModel() with demo project (valid)', () => {
   const filteredDemoProject = structuredClone(demoDb);
   const { data } = parseDatabaseModel(filteredDemoProject);
 
-  it('has 17 events with 12 top level events', () => {
-    expect(data.rundowns.default.order.length).toBe(12);
-    expect(Object.keys(data.rundowns.default.entries).length).toBe(17);
+  it('has 14 entries, with 6 events and 4 top level groups', () => {
+    expect(data.rundowns.default.order.length).toBe(4);
+    expect(Object.keys(data.rundowns.default.entries).length).toBe(14);
+    let numEntries = 0;
+    data.rundowns.default.flatOrder.forEach((entryId) => {
+      const entry = data.rundowns.default.entries[entryId];
+      if (entry.type === SupportedEntry.Event) {
+        numEntries++;
+      }
+    });
+    expect(numEntries).toBe(6);
   });
 
   it('is the same as the demo project since all data is valid', () => {
@@ -32,7 +42,33 @@ describe('test parseDatabaseModel() with demo project (valid)', () => {
     delete filteredDemoProject.settings.version;
     // @ts-expect-error -- its ok
     delete data.settings.version;
-    expect(data).toMatchObject(filteredDemoProject);
+
+    // remove time-related fields from the comparison
+    // these are not calculated in the parser
+    Object.values(filteredDemoProject.rundowns.default.entries).forEach((entry: any) => {
+      if (entry.type === SupportedEntry.Block) {
+        delete entry.timeStart;
+        delete entry.timeEnd;
+        delete entry.duration;
+        delete entry.isFirstLinked;
+      }
+    });
+    Object.values(data.rundowns.default.entries).forEach((entry: any) => {
+      if (entry.type === SupportedEntry.Block) {
+        delete entry.timeStart;
+        delete entry.timeEnd;
+        delete entry.duration;
+        delete entry.isFirstLinked;
+      }
+    });
+
+    expect(data.automation).toMatchObject(filteredDemoProject.automation);
+    expect(data.customFields).toMatchObject(filteredDemoProject.customFields);
+    expect(data.project).toMatchObject(filteredDemoProject.project);
+    expect(data.rundowns).toMatchObject(filteredDemoProject.rundowns);
+    expect(data.settings).toMatchObject(filteredDemoProject.settings);
+    expect(data.urlPresets).toMatchObject(filteredDemoProject.urlPresets);
+    expect(data.viewSettings).toMatchObject(filteredDemoProject.viewSettings);
   });
 });
 

apps/server/src/api-data/rundown/__tests__/rundown.dao.test.ts

@@ -97,12 +97,12 @@ describe('processRundown()', () => {
   it('generates metadata from given rundown', () => {
     const initResult = processRundown(demoDb.rundowns.default, demoDb.customFields);
 
-    expect(initResult.order.length).toBe(12);
-    expect(initResult.flatEntryOrder.length).toBe(17);
-    expect(initResult.timedEventOrder.length).toBe(14);
-    expect(initResult.playableEventOrder.length).toBe(14);
-    expect(initResult.firstStart).toBe(36000000);
-    expect(initResult.lastEnd).toBe(61800000);
+    expect(initResult.order.length).toBe(4);
+    expect(initResult.flatEntryOrder.length).toBe(14);
+    expect(initResult.timedEventOrder.length).toBe(6);
+    expect(initResult.playableEventOrder.length).toBe(6);
+    expect(initResult.firstStart).toBe(MILLIS_PER_HOUR * 10);
+    expect(initResult.lastEnd).toBe(MILLIS_PER_HOUR * 14);
     expect(initResult.totalDays).toBe(0);
     expect(initResult.totalDelay).toBe(0);
   });

apps/server/src/api-data/rundown/rundown.parser.ts

@@ -118,18 +118,22 @@ export function parseRundown(
 
         if (isOntimeEvent(nestedEvent)) {
           newNestedEvent = createEvent(nestedEvent, eventIndex);
+
           // skip if event is invalid
           if (newNestedEvent == null) {
             emitError?.('Skipping event without payload');
             continue;
           }
 
+          newNestedEvent.parent = event.id;
           cleanupCustomFields(newNestedEvent.custom, parsedCustomFields);
           eventIndex += 1;
         } else if (isOntimeDelay(nestedEvent)) {
           newNestedEvent = { ...delayDef, duration: nestedEvent.duration, id: nestedEventId };
+          newNestedEvent.parent = event.id;
         } else if (isOntimeMilestone(nestedEvent)) {
           newNestedEvent = createMilestone({ ...nestedEvent, id: nestedEventId });
+          newNestedEvent.parent = event.id;
           cleanupCustomFields(newNestedEvent.custom, parsedCustomFields);
         }