feat: excel import (#527)

* refactor: simplify excel import

* chore: add external deepmerge utility

* chore: create import map utilities

* chore: increase size limits on uploads

* style: small presentation tweaks

* feat: resolve times on excel import, refs #508

apps/server/src/utils/__tests__/parser.test.ts

@@ -526,7 +526,7 @@ describe('test event validator', () => {
     expect(typeof validated.timeStart).toEqual('number');
     expect(validated.timeStart).toEqual(0);
     expect(typeof validated.timeEnd).toEqual('number');
-    expect(validated.timeEnd).toEqual(0);
+    expect(validated.timeEnd).toEqual(2);
   });
 
   it('handles bad objects', () => {
@@ -580,24 +580,24 @@ describe('test parseExcel function', () => {
       [
         'Time Start',
         'Time End',
-        'Event Title',
-        'Presenter Name',
-        'Event Subtitle',
+        'Title',
+        'Presenter',
+        'Subtitle',
         'End Action',
         'Timer type',
-        'Is Public? (x)',
-        'Skip? (x)',
+        'Public',
+        'Skip',
         'Notes',
-        'User0:test0',
-        'User1:test1',
-        'User2:test2',
-        'User3:test3',
-        'User4:test4',
-        'User5:test5',
-        'User6:test6',
-        'user7:test7',
-        'user8:test8',
-        'user9:test9',
+        'test0',
+        'test1',
+        'test2',
+        'test3',
+        'test4',
+        'test5',
+        'test6',
+        'test7',
+        'test8',
+        'test9',
         'Colour',
         'cue',
       ],
@@ -652,6 +652,19 @@ describe('test parseExcel function', () => {
       [],
     ];
 
+    const partialOptions = {
+      user0: 'test0',
+      user1: 'test1',
+      user2: 'test2',
+      user3: 'test3',
+      user4: 'test4',
+      user5: 'test5',
+      user6: 'test6',
+      user7: 'test7',
+      user8: 'test8',
+      user9: 'test9',
+    };
+
     const expectedParsedProjectData = {
       title: 'Test Event',
       description: 'test description',
@@ -707,7 +720,7 @@ describe('test parseExcel function', () => {
       },
     ];
 
-    const parsedData = await parseExcel(testdata);
+    const parsedData = parseExcel(testdata, partialOptions);
     expect(parsedData.project).toStrictEqual(expectedParsedProjectData);
     expect(parsedData.rundown).toBeDefined();
     expect(parsedData.rundown[0]).toMatchObject(expectedParsedRundown[0]);
@@ -836,7 +849,16 @@ describe('test views import', () => {
         app: 'ontime',
         version: 2,
       },
-      viewSettings: {},
+      viewSettings: {
+        normalColor: '#ffffffcc',
+        warningColor: '#FFAB33',
+        warningThreshold: 120000,
+        dangerColor: '#ED3333',
+        dangerThreshold: 60000,
+        endMessage: '',
+        overrideStyles: false,
+        notAthing: true,
+      },
       views: {
         overrideStyles: true,
       },
@@ -850,7 +872,7 @@ describe('test views import', () => {
       endMessage: '',
       overrideStyles: false,
     };
-    const parsed = parseViewSettings(testData, false);
+    const parsed = parseViewSettings(testData);
     expect(parsed).toStrictEqual(expectedParsedViewSettings);
   });
 
@@ -862,16 +884,7 @@ describe('test views import', () => {
         version: 2,
       },
     };
-    const expectedParsedViewSettings = {
-      normalColor: '#ffffffcc',
-      warningColor: '#FFAB33',
-      warningThreshold: 120000,
-      dangerColor: '#ED3333',
-      dangerThreshold: 60000,
-      endMessage: '',
-      overrideStyles: false,
-    };
-    const parsed = parseViewSettings(testData, true);
-    expect(parsed).toStrictEqual(expectedParsedViewSettings);
+    const parsed = parseViewSettings(testData);
+    expect(parsed).toStrictEqual({});
   });
 });

apps/server/src/utils/__tests__/parserUtils.test.ts

@@ -45,7 +45,7 @@ describe('mergeObject()', () => {
       third: '',
     });
   });
-  test.skip('it only merges fields of the first object', () => {
+  test('it only merges fields of the first object', () => {
     const a = {
       first: 'yes',
       second: 'yes',
@@ -64,6 +64,35 @@ describe('mergeObject()', () => {
       third: '',
     });
   });
+  test('merges nested objects', () => {
+    // Define a sample object with nested properties
+    const a = {
+      name: 'John',
+      address: {
+        city: 'New York',
+        postalCode: '10001',
+      },
+    };
+
+    // Define a partial object with nested properties for merging
+    const b = {
+      name: 'Doe',
+      address: {
+        city: 'San Francisco',
+        state: 'CA',
+      },
+    };
+
+    const merged = mergeObject(a, b);
+
+    expect(merged.name).toBe('Doe');
+    expect(merged.address.city).toBe('San Francisco');
+    // @ts-expect-error -- its ok, just checking
+    expect(merged.address.state).toBe('CA');
+    expect(merged.address.postalCode).toBe('10001');
+    expect(merged.address).not.toBe(a.address);
+    expect(merged.address).not.toBe(b.address);
+  });
 });
 
 describe('removeUndefined()', () => {

apps/server/src/utils/parser.ts

@@ -1,18 +1,27 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck -- not ready to fully type
-
-import fs from 'fs';
-import xlsx from 'node-xlsx';
-import { generateId, calculateDuration } from 'ontime-utils';
+import {
+  generateId,
+  isExcelImportMap,
+  type ExcelImportMap,
+  defaultExcelImportMap,
+  validateEndAction,
+  validateTimerType,
+  type ExcelImportOptions,
+  validateTimes,
+} from 'ontime-utils';
 import {
   DatabaseModel,
-  EndAction,
   OntimeEvent,
   OntimeRundown,
   SupportedEvent,
-  TimerType,
+  ProjectData,
   UserFields,
+  EndAction,
+  TimerType,
 } from 'ontime-types';
+
+import fs from 'fs';
+import xlsx from 'node-xlsx';
+
 import { event as eventDef } from '../models/eventsDefinition.js';
 import { dbModel } from '../models/dataModel.js';
 import { deleteFile, makeString } from './parserUtils.js';
@@ -33,27 +42,55 @@ export const JSON_MIME = 'application/json';
 /**
  * @description Excel array parser
  * @param {array} excelData - array with excel sheet
+ * @param {ExcelImportOptions} options - an object that contains the import map
  * @returns {object} - parsed object
  */
-export const parseExcel = async (excelData) => {
+export const parseExcel = (excelData: unknown[][], options?: Partial<ExcelImportMap>) => {
+  const importMap: ExcelImportMap = { ...defaultExcelImportMap, ...options };
   const projectData: Partial<ProjectData> = {
     title: '',
     description: '',
     publicUrl: '',
+    publicInfo: '',
     backstageUrl: '',
+    backstageInfo: '',
+  };
+  const customUserFields: Partial<UserFields> = {
+    user0: importMap.user0,
+    user1: importMap.user1,
+    user2: importMap.user2,
+    user3: importMap.user3,
+    user4: importMap.user4,
+    user5: importMap.user5,
+    user6: importMap.user6,
+    user7: importMap.user7,
+    user8: importMap.user8,
+    user9: importMap.user9,
   };
-  const customUserFields: Partial<UserFields> = {};
   const rundown: OntimeRundown = [];
-  let timeStartIndex: number | null = null;
-  let timeEndIndex: number | null = null;
+
+  // title stuff: strings
   let titleIndex: number | null = null;
   let cueIndex: number | null = null;
   let presenterIndex: number | null = null;
   let subtitleIndex: number | null = null;
-  let isPublicIndex: number | null = null;
-  let skipIndex: number | null = null;
   let notesIndex: number | null = null;
   let colourIndex: number | null = null;
+
+  // options: booleans
+  let isPublicIndex: number | null = null;
+  let skipIndex: number | null = null;
+
+  // times: numbers
+  let timeStartIndex: number | null = null;
+  let timeEndIndex: number | null = null;
+  let durationIndex: number | null = null;
+
+  // options: enum properties
+  let endActionIndex: number | null = null;
+  let timerTypeIndex: number | null = null;
+
+  // user fields: strings
   let user0Index: number | null = null;
   let user1Index: number | null = null;
   let user2Index: number | null = null;
@@ -64,13 +101,11 @@ export const parseExcel = async (excelData) => {
   let user7Index: number | null = null;
   let user8Index: number | null = null;
   let user9Index: number | null = null;
-  let endActionIndex: number | null = null;
-  let timerTypeIndex: number | null = null;
 
   excelData
     .filter((e) => e.length > 0)
     .forEach((row) => {
-      // project data imports are on the column to the right
+      // these fields contain the data to its right
       let projectTitleNext = false;
       let projectDescriptionNext = false;
       let publicUrlNext = false;
@@ -79,31 +114,68 @@ export const parseExcel = async (excelData) => {
       let backstageInfoNext = false;
 
       const event: Partial<OntimeEvent> = {};
+      const handlers = {
+        [importMap.projectName]: () => (projectTitleNext = true),
+        [importMap.projectDescription]: () => (projectDescriptionNext = true),
+        [importMap.publicUrl]: () => (publicUrlNext = true),
+        [importMap.publicInfo]: () => (publicInfoNext = true),
+        [importMap.backstageUrl]: () => (backstageUrlNext = true),
+        [importMap.backstageInfo]: () => (backstageInfoNext = true),
+
+        [importMap.timeStart]: (index: number) => (timeStartIndex = index),
+        [importMap.timeEnd]: (index: number) => (timeEndIndex = index),
+        [importMap.duration]: (index: number) => (durationIndex = index),
+
+        [importMap.cue]: (index: number) => (cueIndex = index),
+        [importMap.title]: (index: number) => (titleIndex = index),
+        [importMap.presenter]: (index: number) => (presenterIndex = index),
+        [importMap.subtitle]: (index: number) => (subtitleIndex = index),
+        [importMap.isPublic]: (index: number) => (isPublicIndex = index),
+        [importMap.skip]: (index: number) => (skipIndex = index),
+        [importMap.note]: (index: number) => (notesIndex = index),
+        [importMap.colour]: (index: number) => (colourIndex = index),
+
+        [importMap.endAction]: (index: number) => (endActionIndex = index),
+        [importMap.timerType]: (index: number) => (timerTypeIndex = index),
+
+        [importMap.user0]: (index: number) => (user0Index = index),
+        [importMap.user1]: (index: number) => (user1Index = index),
+        [importMap.user2]: (index: number) => (user2Index = index),
+        [importMap.user3]: (index: number) => (user3Index = index),
+        [importMap.user4]: (index: number) => (user4Index = index),
+        [importMap.user5]: (index: number) => (user5Index = index),
+        [importMap.user6]: (index: number) => (user6Index = index),
+        [importMap.user7]: (index: number) => (user7Index = index),
+        [importMap.user8]: (index: number) => (user8Index = index),
+        [importMap.user9]: (index: number) => (user9Index = index),
+      } as const;
 
       row.forEach((column, j) => {
-        // check flags
+        // 1. we check if we have set a flag for a known field
         if (projectTitleNext) {
-          projectData.title = column;
+          projectData.title = makeString(column, '');
           projectTitleNext = false;
         } else if (projectDescriptionNext) {
-          projectData.description = column;
+          projectData.description = makeString(column, '');
           projectDescriptionNext = false;
         } else if (publicUrlNext) {
-          projectData.publicUrl = column;
+          projectData.publicUrl = makeString(column, '');
           publicUrlNext = false;
         } else if (publicInfoNext) {
-          projectData.publicInfo = column;
+          projectData.publicInfo = makeString(column, '');
           publicInfoNext = false;
         } else if (backstageUrlNext) {
-          projectData.backstageUrl = column;
+          projectData.backstageUrl = makeString(column, '');
           backstageUrlNext = false;
         } else if (backstageInfoNext) {
-          projectData.backstageInfo = column;
+          projectData.backstageInfo = makeString(column, '');
           backstageInfoNext = false;
         } else if (j === timeStartIndex) {
           event.timeStart = parseExcelDate(column);
         } else if (j === timeEndIndex) {
           event.timeEnd = parseExcelDate(column);
+        } else if (j === durationIndex) {
+          event.duration = parseExcelDate(column);
         } else if (j === titleIndex) {
           event.title = makeString(column, '');
         } else if (j === cueIndex) {
@@ -119,166 +191,51 @@ export const parseExcel = async (excelData) => {
         } else if (j === notesIndex) {
           event.note = makeString(column, '');
         } else if (j === endActionIndex) {
-          if (column === '') {
-            event.endAction = EndAction.None;
-          } else {
-            event.endAction = column;
-          }
+          event.endAction = validateEndAction(column);
         } else if (j === timerTypeIndex) {
-          if (column === '') {
-            event.timerType = TimerType.CountDown;
-          } else {
-            event.timerType = column;
-          }
+          event.timerType = validateTimerType(column);
         } else if (j === colourIndex) {
-          event.colour = column;
+          event.colour = makeString(column, '');
         } else if (j === user0Index) {
-          event.user0 = column;
+          event.user0 = makeString(column, '');
         } else if (j === user1Index) {
-          event.user1 = column;
+          event.user1 = makeString(column, '');
         } else if (j === user2Index) {
-          event.user2 = column;
+          event.user2 = makeString(column, '');
         } else if (j === user3Index) {
-          event.user3 = column;
+          event.user3 = makeString(column, '');
         } else if (j === user4Index) {
-          event.user4 = column;
+          event.user4 = makeString(column, '');
         } else if (j === user5Index) {
-          event.user5 = column;
+          event.user5 = makeString(column, '');
         } else if (j === user6Index) {
-          event.user6 = column;
+          event.user6 = makeString(column, '');
         } else if (j === user7Index) {
-          event.user7 = column;
+          event.user7 = makeString(column, '');
         } else if (j === user8Index) {
-          event.user8 = column;
+          event.user8 = makeString(column, '');
         } else if (j === user9Index) {
-          event.user9 = column;
+          event.user9 = makeString(column, '');
         } else {
+          // 2. if there is no flag, lets see if we know the field type
           if (typeof column === 'string') {
             const col = column.toLowerCase();
 
-            // look for keywords
-            // need to make sure it is a string first
-            switch (col) {
-              case 'project name':
-                projectTitleNext = true;
-                break;
-              case 'project description':
-                projectDescriptionNext = true;
-                break;
-              case 'public url':
-                publicUrlNext = true;
-                break;
-              case 'public info':
-                publicInfoNext = true;
-                break;
-              case 'backstage url':
-                backstageUrlNext = true;
-                break;
-              case 'backstage info':
-                backstageInfoNext = true;
-                break;
-              case 'time start':
-              case 'start':
-                timeStartIndex = j;
-                break;
-              case 'time end':
-              case 'end':
-              case 'finish':
-                timeEndIndex = j;
-                break;
-              case 'cue':
-              case 'page':
-                cueIndex = j;
-                break;
-              case 'event title':
-              case 'title':
-                titleIndex = j;
-                break;
-              case 'presenter name':
-              case 'speaker':
-              case 'presenter':
-                presenterIndex = j;
-                break;
-              case 'event subtitle':
-              case 'subtitle':
-                subtitleIndex = j;
-                break;
-              case 'is public? (x)':
-              case 'is public':
-              case 'public':
-                isPublicIndex = j;
-                break;
-              case 'skip? (x)':
-              case 'skip?':
-              case 'skip':
-                skipIndex = j;
-                break;
-              case 'note':
-              case 'notes':
-                notesIndex = j;
-                break;
-              case 'colour':
-              case 'color':
-                colourIndex = j;
-                break;
-              case 'end action':
-                endActionIndex = j;
-                break;
-              case 'timer type':
-                timerTypeIndex = j;
-                break;
-              default:
-                // look for user defined
-                if (col.startsWith('user')) {
-                  const index = column.charAt(4);
-                  // name is the bit after the :
-                  const [, name] = column.split(':');
-                  if (typeof name !== 'undefined') {
-                    if (index === '0') {
-                      customUserFields.user0 = name;
-                      user0Index = j;
-                    } else if (index === '1') {
-                      customUserFields.user1 = name;
-                      user1Index = j;
-                    } else if (index === '2') {
-                      customUserFields.user2 = name;
-                      user2Index = j;
-                    } else if (index === '3') {
-                      customUserFields.user3 = name;
-                      user3Index = j;
-                    } else if (index === '4') {
-                      customUserFields.user4 = name;
-                      user4Index = j;
-                    } else if (index === '5') {
-                      customUserFields.user5 = name;
-                      user5Index = j;
-                    } else if (index === '6') {
-                      customUserFields.user6 = name;
-                      user6Index = j;
-                    } else if (index === '7') {
-                      customUserFields.user7 = name;
-                      user7Index = j;
-                    } else if (index === '8') {
-                      customUserFields.user8 = name;
-                      user8Index = j;
-                    } else if (index === '9') {
-                      customUserFields.user9 = name;
-                      user9Index = j;
-                    }
-                  }
-                }
-                break;
+            if (handlers[col]) {
+              handlers[col](j);
             }
+            // else. we don't know how to handle this column
+            // just ignore it
           }
         }
       });
 
       if (Object.keys(event).length > 0) {
         // if any data was found, push to array
-        // take care of it in the next step
         rundown.push({ ...event, type: SupportedEvent.Event } as OntimeEvent);
       }
     });
+
   return {
     rundown,
     project: projectData,
@@ -286,17 +243,16 @@ export const parseExcel = async (excelData) => {
       app: 'ontime',
       version: 2,
     },
-    userFields: { ...dbModel.userFields, ...customUserFields },
+    userFields: customUserFields,
   };
 };
 
 /**
- * @description JSON parser function for v1 of data system
- * @param {object} jsonData - json data JSON object to be parsed
- * @param {boolean} [enforce=false] - flag, tells to create an object anyway
+ * @description JSON parser function for ontime project file
+ * @param {object} jsonData - project file to be parsed
  * @returns {object} - parsed object
  */
-export const parseJson = async (jsonData, enforce = false): Promise<DatabaseModel | null> => {
+export const parseJson = async (jsonData): Promise<DatabaseModel | null> => {
   if (!jsonData || typeof jsonData !== 'object') {
     return null;
   }
@@ -307,17 +263,17 @@ export const parseJson = async (jsonData, enforce = false): Promise<DatabaseMode
   // parse Events
   returnData.rundown = parseRundown(jsonData);
   // parse Event
-  returnData.project = parseProject(jsonData, enforce);
+  returnData.project = parseProject(jsonData) ?? dbModel.project;
   // Settings handled partially
-  returnData.settings = parseSettings(jsonData, enforce);
+  returnData.settings = parseSettings(jsonData) ?? dbModel.settings;
   // View settings handled partially
-  returnData.viewSettings = parseViewSettings(jsonData, enforce);
+  returnData.viewSettings = parseViewSettings(jsonData) ?? dbModel.viewSettings;
   // Import Aliases if any
   returnData.aliases = parseAliases(jsonData);
   // Import user fields if any
   returnData.userFields = parseUserFields(jsonData);
   // Import OSC settings if any
-  returnData.osc = parseOsc(jsonData, enforce);
+  returnData.osc = parseOsc(jsonData) ?? dbModel.osc;
   // Import HTTP settings if any
   // returnData.http = parseHttp(jsonData, enforce);
 
@@ -344,19 +300,19 @@ export const validateEvent = (eventArgs: Partial<OntimeEvent>, cueFallback: stri
 
     const e = eventArgs;
     const d = eventDef;
-    const start = e.timeStart != null && typeof e.timeStart === 'number' ? e.timeStart : d.timeStart;
-    const end = e.timeEnd != null && typeof e.timeEnd === 'number' ? e.timeEnd : d.timeEnd;
+
+    const { timeStart, timeEnd, duration } = validateTimes(e.timeStart, e.timeEnd, e.duration);
 
     event = {
       ...d,
       title: makeString(e.title, d.title),
       subtitle: makeString(e.subtitle, d.subtitle),
       presenter: makeString(e.presenter, d.presenter),
-      timeStart: start,
-      timeEnd: end,
-      endAction: makeString(e.endAction, d.endAction),
-      timerType: makeString(e.timerType, d.timerType),
-      duration: calculateDuration(start, end),
+      timeStart,
+      timeEnd,
+      duration,
+      endAction: validateEndAction(e.endAction, EndAction.None),
+      timerType: validateTimerType(e.timerType, TimerType.CountDown),
       isPublic: typeof e.isPublic === 'boolean' ? e.isPublic : d.isPublic,
       skip: typeof e.skip === 'boolean' ? e.skip : d.skip,
       note: makeString(e.note, d.note),
@@ -371,8 +327,8 @@ export const validateEvent = (eventArgs: Partial<OntimeEvent>, cueFallback: stri
       user8: makeString(e.user8, d.user8),
       user9: makeString(e.user9, d.user9),
       colour: makeString(e.colour, d.colour),
-      id,
       cue: makeString(e.cue, cueFallback),
+      id,
       type: 'event',
     };
   }
@@ -380,68 +336,59 @@ export const validateEvent = (eventArgs: Partial<OntimeEvent>, cueFallback: stri
   return event;
 };
 
-type ResponseOK = { data: Partial<DatabaseModel>; message: 'success' };
-type ResponseError = { error: true; message: string };
+type ResponseOK = {
+  data: Partial<DatabaseModel>;
+};
 
 /**
  * @description Middleware function that checks file type and calls relevant parser
  * @param {string} file - reference to file
+ * @param options - import options
  * @return {object} - parse result message
  */
-export const fileHandler = async (file): Promise<ResponseOK | ResponseError> => {
-  let res: Partial<ResponseOK | ResponseError> = {};
+export const fileHandler = async (file: string, options: ExcelImportOptions): Promise<Partial<ResponseOK>> => {
+  const res: Partial<ResponseOK> = {};
 
   // check which file type are we dealing with
   if (file.endsWith('.xlsx')) {
-    try {
-      const excelData = xlsx
-        .parse(file, { cellDates: true })
-        .find(({ name }) => name.toLowerCase() === 'ontime' || name.toLowerCase() === 'event schedule');
-
-      // we only look at worksheets called ontime or event schedule
-      if (excelData?.data) {
-        const dataFromExcel = await parseExcel(excelData.data);
-        res.data = {};
-        res.data.rundown = parseRundown(dataFromExcel);
-        res.data.project = parseProject(dataFromExcel, true);
-        res.data.userFields = parseUserFields(dataFromExcel);
-        res.message = 'success';
-      } else {
-        const errorMessage = 'No sheet found named "ontime" or "event schedule"';
-        res = {
-          error: true,
-          message: errorMessage,
-        };
-      }
-    } catch (error) {
-      res = { error: true, message: `Error parsing file: ${error}` };
+    // we need to check that the options are applicable
+    if (!isExcelImportMap(options)) {
+      throw new Error('Got incorrect options to excel import', JSON.parse(options));
     }
+
+    const excelData = xlsx
+      .parse(file, { cellDates: true })
+      .find(({ name }) => name.toLowerCase() === options.worksheet.toLowerCase());
+
+    if (!excelData?.data) {
+      throw new Error(`Could not find data to import, maybe the worksheet name is incorrect: ${options.worksheet}`);
+    }
+
+    const dataFromExcel = parseExcel(excelData.data, options);
+    // we run the parsed data through an extra step to ensure the objects shape
+    res.data = {};
+    res.data.rundown = parseRundown(dataFromExcel);
+    if (res.data.rundown.length < 1) {
+      throw new Error(`Could not find data to import in the worksheet ${options.worksheet}`);
+    }
+    res.data.project = parseProject(dataFromExcel);
+    res.data.userFields = parseUserFields(dataFromExcel);
+    return res;
   }
 
   if (file.endsWith('.json')) {
     // if json check version
-    const rawdata = fs.readFileSync(file);
+    const rawdata = fs.readFileSync(file).toString();
     let uploadedJson = null;
 
-    try {
-      uploadedJson = JSON.parse(rawdata);
-    } catch (error) {
-      return { error: true, message: 'Error parsing JSON file' };
+    uploadedJson = JSON.parse(rawdata);
+    if (uploadedJson.settings.version !== 2) {
+      throw new Error(`Project version unknown ${uploadedJson.settings.version}`);
     }
+    res.data = await parseJson(uploadedJson);
 
-    if (uploadedJson.settings.version === 2) {
-      try {
-        res.data = await parseJson(uploadedJson);
-        res.message = 'success';
-      } catch (error) {
-        res = { error: true, message: `Error parsing file: ${error}` };
-      }
-    } else {
-      res = { error: true, message: 'Error parsing file, version unknown' };
-    }
+    // delete file
+    await deleteFile(file);
+    return res;
   }
-
-  // delete file
-  await deleteFile(file);
-  return res;
 };

apps/server/src/utils/parserFunctions.ts

@@ -1,7 +1,6 @@
 import { generateId } from 'ontime-utils';
 import {
   Alias,
-  EndAction,
   OntimeRundown,
   OSCSettings,
   OscSubscription,
@@ -9,7 +8,6 @@ import {
   ProjectData,
   Settings,
   TimerLifeCycle,
-  TimerType,
   UserFields,
   ViewSettings,
 } from 'ontime-types';
@@ -45,18 +43,6 @@ export const parseRundown = (data): OntimeRundown => {
           continue;
         }
 
-        // validate the right endAction is used
-        if (e.endAction && !Object.values(EndAction).includes(e.endAction)) {
-          e.endAction = EndAction.None;
-          console.log('WARNING: invalid End Action provided, using default');
-        }
-
-        // validate the right timerType is used
-        if (e.timerType && !Object.values(TimerType).includes(e.timerType)) {
-          e.timerType = TimerType.CountDown;
-          console.log('WARNING: invalid Timer Type provided, using default');
-        }
-
         if (e.type === 'event') {
           eventIndex += 1;
           const event = validateEvent(e, eventIndex.toString());
@@ -88,10 +74,9 @@ export const parseRundown = (data): OntimeRundown => {
 /**
  * Parse event portion of an entry
  * @param {object} data - data object
- * @param {boolean} enforce - whether to create a definition if one is missing
  * @returns {object} - event object data
  */
-export const parseProject = (data, enforce): ProjectData => {
+export const parseProject = (data): ProjectData => {
   let newProjectData: Partial<ProjectData> = {};
   // we are adding this here to aid transition, should be removed once enough time has past that users have fully migrated
   // TODO: Remove eventually
@@ -109,9 +94,6 @@ export const parseProject = (data, enforce): ProjectData => {
       backstageUrl: project.backstageUrl || dbModel.project.backstageUrl,
       backstageInfo: project.backstageInfo || dbModel.project.backstageInfo,
     };
-  } else if (enforce) {
-    newProjectData = { ...dbModel.project };
-    console.log('Created project object in db');
   }
   return newProjectData as ProjectData;
 };
@@ -119,10 +101,9 @@ export const parseProject = (data, enforce): ProjectData => {
 /**
  * Parse settings portion of an entry
  * @param {object} data - data object
- * @param {boolean} enforce - whether to create a definition if one is missing
  * @returns {object} - event object data
  */
-export const parseSettings = (data, enforce): Settings => {
+export const parseSettings = (data): Settings => {
   let newSettings: Partial<Settings> = {};
   if ('settings' in data) {
     console.log('Found settings definition, importing...');
@@ -146,9 +127,6 @@ export const parseSettings = (data, enforce): Settings => {
         ...settings,
       };
     }
-  } else if (enforce) {
-    newSettings = dbModel.settings;
-    console.log('Created settings object in db');
   }
   return newSettings as Settings;
 };
@@ -156,10 +134,9 @@ export const parseSettings = (data, enforce): Settings => {
 /**
  * Parse settings portion of an entry
  * @param {object} data - data object
- * @param {boolean} enforce - whether to create a definition if one is missing
  * @returns {object} - event object data
  */
-export const parseViewSettings = (data, enforce): ViewSettings => {
+export const parseViewSettings = (data): ViewSettings => {
   let newViews: Partial<ViewSettings> = {};
   if ('viewSettings' in data) {
     console.log('Found view definition, importing...');
@@ -175,13 +152,7 @@ export const parseViewSettings = (data, enforce): ViewSettings => {
       endMessage: v.endMessage ?? dbModel.viewSettings.endMessage,
     };
 
-    // write to db
-    newViews = {
-      ...viewSettings,
-    };
-  } else if (enforce) {
-    newViews = dbModel.viewSettings;
-    console.log('Created viewSettings object in db');
+    newViews = { ...viewSettings };
   }
   return newViews as ViewSettings;
 };
@@ -224,16 +195,11 @@ export const validateOscObject = (data: OscSubscription): boolean => {
 /**
  * Parse osc portion of an entry
  */
-export const parseOsc = (
-  data: {
-    osc?: Partial<OSCSettings>;
-  },
-  enforce: boolean,
-): OSCSettings | Record<string, never> => {
+export const parseOsc = (data: { osc?: Partial<OSCSettings> }): OSCSettings => {
   if ('osc' in data) {
     console.log('Found OSC definition, importing...');
 
-    const loadedConfig = data?.osc || {};
+    const loadedConfig = data.osc || {};
     const validatedSubscriptions = validateOscObject(loadedConfig.subscriptions)
       ? loadedConfig.subscriptions
       : dbModel.osc.subscriptions;
@@ -246,10 +212,7 @@ export const parseOsc = (
       enabledOut: loadedConfig.enabledOut ?? dbModel.osc.enabledOut,
       subscriptions: validatedSubscriptions,
     };
-  } else if (enforce) {
-    console.log('Created OSC object in db');
-    return { ...dbModel.osc };
-  } else return {};
+  }
 };
 
 /**

apps/server/src/utils/parserUtils.ts

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import { deepmerge } from 'ontime-utils';
 
 /**
  * @description Ensures variable is string, it skips object types
@@ -52,16 +53,30 @@ export const isEmptyObject = (obj: object) => {
 
 /**
  * @description Merges two objects, suppressing undefined keys
- * @param {object} a
- * @param {object} b
+ * @param {object} a - any object
+ * @param {object} b - a potential partial object of same time as a
  */
-export const mergeObject = (a, b) => {
-  const merged = {};
-  Object.keys({ ...a, ...b }).map((key) => {
-    merged[key] = typeof b[key] === 'undefined' ? a[key] : b[key];
-  });
+export function mergeObject<T extends Record<string, any>>(a: T, b: Partial<Record<keyof T, any>>): T {
+  const merged = { ...a };
+
+  for (const key in b) {
+    const aValue = a[key];
+    const bValue = b[key];
+
+    // ignore keys that do not exist in original object
+    if (!Object.hasOwn(merged, key)) {
+      continue;
+    }
+
+    if (typeof bValue === 'object' && bValue !== null && typeof aValue === 'object' && aValue !== null) {
+      // @ts-expect-error -- library side, ignore for now
+      merged[key] = deepmerge(aValue, bValue);
+    } else if (bValue !== undefined) {
+      merged[key] = bValue;
+    }
+  }
   return merged;
-};
+}
 
 /**
  * @description Removes undefined

apps/server/src/utils/time.ts

@@ -89,14 +89,18 @@ export const forgivingStringToMillis = (value: string, fillLeft = true): number
  * @returns {number} - time in milliseconds
 
  */
-export const parseExcelDate = (excelDate: string): number => {
-  // attempt converting to date object
-  const date = new Date(excelDate);
-  if (date instanceof Date && !isNaN(date.getTime())) {
-    return dateToMillis(date);
-  } else if (isTimeString(excelDate)) {
-    return forgivingStringToMillis(excelDate);
+export const parseExcelDate = (excelDate: unknown): number => {
+  if (excelDate instanceof Date) {
+    return dateToMillis(excelDate);
+  } else if (typeof excelDate === 'string') {
+    const date = new Date(excelDate);
+    if (date instanceof Date && !isNaN(date.getTime())) {
+      return dateToMillis(date);
+    } else if (isTimeString(excelDate)) {
+      return forgivingStringToMillis(excelDate);
+    }
   }
+
   return 0;
 };
 

apps/server/src/utils/url.js

@@ -1,19 +0,0 @@
-/**
- * @description Cleans given url
- * @param {string} url - URL to be checked
- * @returns {string} Sanitized url
- */
-export const cleanURL = (url) => {
-  // trim whitespaces
-  let r = url.trim();
-
-  // clear any whitespaces
-  r = r.split(' ').join('%20');
-
-  // contain only allowed characters
-  r = r.replace(/([@\s<>[\]{}|\\^])+/g, '');
-  // starts with http://
-  if (!r.startsWith('http://')) r = `http://${r}`;
-
-  return r;
-};

apps/server/src/utils/url.ts

@@ -0,0 +1,20 @@
+/**
+ * @description Cleans given url
+ * @param {string} url - URL to be checked
+ * @returns {string} Sanitized url
+ */
+export const cleanURL = (url: string): string => {
+  // trim whitespaces
+  let sanitised = url.trim();
+
+  // clear any whitespaces
+  sanitised = sanitised.split(' ').join('%20');
+
+  // contain only allowed characters
+  sanitised = sanitised.replace(/([@\s<>[\]{}|\\^])+/g, '');
+
+  // starts with http://
+  if (!sanitised.startsWith('http://')) sanitised = `http://${sanitised}`;
+
+  return sanitised;
+};