cpvalente/ontime
1
0
Fork 0
mirror of https://github.com/cpvalente/ontime.git synced 2026-08-10 01:43:43 +00:00
Code Issues Packages Projects Releases 10 Wiki Activity

refactor: remove legacy service

Browse Source
This commit is contained in:
Carlos Valente
2025-01-11 16:06:43 +01:00
committed by Carlos Valente
parent 1f71d4578c
commit 2cc434b0e9
50 changed files with 60 additions and 1851 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/server/src/api-data/automation/automation.parser.ts
+30 -1
View File
@@ -3,11 +3,40 @@ import { DatabaseModel, AutomationSettings, Automation, NormalisedAutomationBlue
import { dbModel } from '../../models/dataModel.js';
import type { ErrorEmitter } from '../../utils/parser.js';
export function parseAutomationSettings(data: Partial<DatabaseModel>, emitError?: ErrorEmitter): AutomationSettings {
interface LegacyData extends Partial<DatabaseModel> {
http?: unknown;
osc?: {
enabledIn?: boolean;
portIn?: number;
};
}
export function parseAutomationSettings(data: LegacyData, emitError?: ErrorEmitter): AutomationSettings {
/**
* Leaving a path for migrating users to the new automations
* This should be removed after a few releases
*/
if (data.http || data.osc) {
emitError?.('Found legacy integrations');
console.log('Found legacy integrations...');
if (data.osc) {
return {
enabledAutomations: dbModel.automation.enabledAutomations,
enabledOscIn: data.osc?.enabledIn ?? dbModel.automation.enabledOscIn,
oscPortIn: data.osc?.portIn ?? dbModel.automation.oscPortIn,
automations: [],
blueprints: {},
};
} else {
return { ...dbModel.automation };
}
}
if (!data.automation) {
emitError?.('No data found to import');
return { ...dbModel.automation };
}
console.log('Found Automation settings, importing...');
return {
enabledAutomations: data.automation.enabledAutomations ?? dbModel.automation.enabledAutomations,
apps/server/src/api-data/db/db.controller.ts
+1 -3
View File
@@ -18,7 +18,7 @@ import * as projectService from '../../services/project-service/ProjectService.j
export async function patchPartialProjectFile(req: Request, res: Response<DatabaseModel | ErrorResponse>) {
try {
const { rundown, project, settings, viewSettings, urlPresets, customFields, osc, http, automation } = req.body;
const { rundown, project, settings, viewSettings, urlPresets, customFields, automation } = req.body;
const patchDb: DatabaseModel = {
rundown,
project,
@@ -26,8 +26,6 @@ export async function patchPartialProjectFile(req: Request, res: Response<Databa
viewSettings,
urlPresets,
customFields,
osc,
http,
automation,
};
apps/server/src/api-data/http/http.controller.ts
-31
View File
@@ -1,31 +0,0 @@
import type { ErrorResponse, HttpSettings } from 'ontime-types';
import { getErrorMessage } from 'ontime-utils';
import type { Request, Response } from 'express';
import { failEmptyObjects } from '../../utils/routerUtils.js';
import { httpIntegration } from '../../services/integration-service/HttpIntegration.js';
import { getDataProvider } from '../../classes/data-provider/DataProvider.js';
export async function getHTTP(_req: Request, res: Response<HttpSettings>) {
const http = getDataProvider().getHttp();
res.status(200).send(http);
}
export async function postHTTP(req: Request, res: Response<HttpSettings | ErrorResponse>) {
if (failEmptyObjects(req.body, res)) {
return;
}
try {
const httpSettings = req.body;
httpIntegration.init(httpSettings);
// we persist the data after init to avoid persisting invalid data
const result = await getDataProvider().setHttp(httpSettings);
res.send(result).status(200);
} catch (error) {
const message = getErrorMessage(error);
res.status(400).send({ message });
}
}
apps/server/src/api-data/http/http.router.ts
-9
View File
@@ -1,9 +0,0 @@
import express from 'express';
import { validateHTTP } from './http.validation.js';
import { getHTTP, postHTTP } from './http.controller.js';
export const router = express.Router();
router.get('/', getHTTP);
router.post('/', validateHTTP, postHTTP);
apps/server/src/api-data/http/http.validation.ts
-21
View File
@@ -1,21 +0,0 @@
import { body, validationResult } from 'express-validator';
import { Request, Response, NextFunction } from 'express';
import { sanitiseHttpSubscriptions } from '../../utils/parserFunctions.js';
/**
* @description Validates object for POST /ontime/http
*/
export const validateHTTP = [
body('enabledOut').exists().isBoolean(),
body('subscriptions')
.exists()
.isArray()
.custom((value) => sanitiseHttpSubscriptions(value)),
(req: Request, res: Response, next: NextFunction) => {
const errors = validationResult(req);
if (!errors.isEmpty()) return res.status(422).json({ errors: errors.array() });
next();
},
];
apps/server/src/api-data/index.ts
-4
View File
@@ -4,8 +4,6 @@ import { router as automationsRouter } from './automation/automation.router.js';
import { router as urlPresetsRouter } from './url-presets/urlPresets.router.js';
import { router as customFieldsRouter } from './custom-fields/customFields.router.js';
import { router as dbRouter } from './db/db.router.js';
import { router as httpRouter } from './http/http.router.js';
import { router as oscRouter } from './osc/osc.router.js';
import { router as projectRouter } from './project/project.router.js';
import { router as rundownRouter } from './rundown/rundown.router.js';
import { router as settingsRouter } from './settings/settings.router.js';
@@ -19,8 +17,6 @@ export const appRouter = express.Router();
appRouter.use('/automations', automationsRouter);
appRouter.use('/custom-fields', customFieldsRouter);
appRouter.use('/db', dbRouter);
appRouter.use('/http', httpRouter);
appRouter.use('/osc', oscRouter);
appRouter.use('/project', projectRouter);
appRouter.use('/rundown', rundownRouter);
appRouter.use('/settings', settingsRouter);
apps/server/src/api-data/osc/osc.controller.ts
-32
View File
@@ -1,32 +0,0 @@
import type { ErrorResponse, OSCSettings } from 'ontime-types';
import { getErrorMessage } from 'ontime-utils';
import type { Request, Response } from 'express';
import { failEmptyObjects } from '../../utils/routerUtils.js';
import { oscIntegration } from '../../services/integration-service/OscIntegration.js';
import { getDataProvider } from '../../classes/data-provider/DataProvider.js';
export async function getOSC(_req: Request, res: Response<OSCSettings>) {
const osc = getDataProvider().getOsc();
res.status(200).send(osc);
}
export async function postOSC(req: Request, res: Response<OSCSettings | ErrorResponse>) {
if (failEmptyObjects(req.body, res)) {
return;
}
try {
const oscSettings = req.body;
oscIntegration.init(oscSettings);
// we persist the data after init to avoid persisting invalid data
const result = await getDataProvider().setOsc(oscSettings);
res.send(result).status(200);
} catch (error) {
const message = getErrorMessage(error);
res.status(400).send({ message });
}
}
apps/server/src/api-data/osc/osc.router.ts
-8
View File
@@ -1,8 +0,0 @@
import express from 'express';
import { getOSC, postOSC } from './osc.controller.js';
import { validateOSC } from './osc.validation.js';
export const router = express.Router();
router.get('/', getOSC);
router.post('/', validateOSC, postOSC);
apps/server/src/api-data/osc/osc.validation.ts
-25
View File
@@ -1,25 +0,0 @@
import { body, validationResult } from 'express-validator';
import { Request, Response, NextFunction } from 'express';
import { sanitiseOscSubscriptions } from '../../utils/parserFunctions.js';
/**
* @description Validates object for POST /ontime/osc
*/
export const validateOSC = [
body('portIn').exists().isPort(),
body('portOut').exists().isPort(),
body('targetIP').exists().isIP(),
body('enabledIn').exists().isBoolean(),
body('enabledOut').exists().isBoolean(),
body('subscriptions')
.exists()
.isArray()
.custom((value) => sanitiseOscSubscriptions(value)),
(req: Request, res: Response, next: NextFunction) => {
const errors = validationResult(req);
if (!errors.isEmpty()) return res.status(422).json({ errors: errors.array() });
next();
},
];
apps/server/src/api-data/session/session.service.ts
-2
View File
@@ -34,7 +34,6 @@ export async function getSessionStats(): Promise<SessionStats> {
*/
export async function getInfo(): Promise<GetInfo> {
const { version, serverPort } = getDataProvider().getSettings();
const osc = getDataProvider().getOsc();
// get nif and inject localhost
const ni = getNetworkInterfaces();
@@ -44,7 +43,6 @@ export async function getInfo(): Promise<GetInfo> {
networkInterfaces: ni,
version,
serverPort,
osc,
publicDir: publicDir.root,
};
}
apps/server/src/app.ts
+2 -33
View File
@@ -27,10 +27,7 @@ import { socket } from './adapters/WebsocketAdapter.js';
import { getDataProvider } from './classes/data-provider/DataProvider.js';
// Services
import { integrationService } from './services/integration-service/IntegrationService.js';
import { logger } from './classes/Logger.js';
import { oscIntegration } from './services/integration-service/OscIntegration.js';
import { httpIntegration } from './services/integration-service/HttpIntegration.js';
import { populateStyles } from './setup/loadStyles.js';
import { eventStore } from './stores/EventStore.js';
import { runtimeService } from './services/runtime-service/RuntimeService.js';
@@ -134,7 +131,7 @@ let expressServer: Server | null = null;
const checkStart = (currentState: OntimeStartOrder) => {
if (step !== currentState) {
step = OntimeStartOrder.Error;
throw new Error('Init order error: initAssets > startServer > startOsc > startIntegrations');
throw new Error('Init order error: initAssets > startServer');
} else {
if (step === 1 || step === 2) {
step = step + 1;
@@ -234,34 +231,6 @@ export const startServer = async (
*/
export const startIntegrations = async () => {
checkStart(OntimeStartOrder.InitIO);
// if a config is not provided, we use the persisted one
const { osc, http } = getDataProvider().getData();
if (http) {
logger.info(LogOrigin.Tx, 'Initialising HTTP Integration...');
try {
httpIntegration.init(http);
integrationService.register(httpIntegration);
} catch (error) {
logger.error(LogOrigin.Tx, `HTTP Integration initialisation failed: ${error}`);
}
}
if (isOntimeCloud) {
logger.info(LogOrigin.Tx, 'Skipping OSC in Cloud environment...');
return;
}
if (osc) {
logger.info(LogOrigin.Tx, 'Initialising OSC Integration...');
try {
oscIntegration.init(osc);
integrationService.register(oscIntegration);
} catch (error) {
logger.error(LogOrigin.Tx, 'OSC Integration initialisation failed');
}
}
};
/**
@@ -283,8 +252,8 @@ export const shutdown = async (exitCode = 0) => {
expressServer?.close();
runtimeService.shutdown();
integrationService.shutdown();
logger.shutdown();
oscServer.shutdown();
socket.shutdown();
process.exit(exitCode);
};
apps/server/src/classes/data-provider/DataProvider.ts
-29
View File
@@ -3,10 +3,8 @@ import {
OntimeRundown,
ViewSettings,
DatabaseModel,
OSCSettings,
Settings,
CustomFields,
HttpSettings,
URLPreset,
AutomationSettings,
} from 'ontime-types';
@@ -49,14 +47,10 @@ export function getDataProvider() {
setRundown,
getSettings,
setSettings,
getOsc,
getHttp,
getUrlPresets,
setUrlPresets,
getViewSettings,
setViewSettings,
setOsc,
setHttp,
getAutomation,
setAutomation,
getRundown,
@@ -104,14 +98,6 @@ async function setSettings(newData: Settings): ReadonlyPromise<Settings> {
return db.data.settings;
}
function getOsc(): Readonly<OSCSettings> {
return db.data.osc;
}
function getHttp(): Readonly<HttpSettings> {
return db.data.http;
}
function getUrlPresets(): Readonly<URLPreset[]> {
return db.data.urlPresets;
}
@@ -132,19 +118,6 @@ async function setViewSettings(newData: ViewSettings): ReadonlyPromise<ViewSetti
return db.data.viewSettings;
}
async function setOsc(newData: OSCSettings): ReadonlyPromise<OSCSettings> {
db.data.osc = { ...newData };
await persist();
return db.data.osc;
}
async function setHttp(newData: HttpSettings): ReadonlyPromise<HttpSettings> {
db.data.http = { ...newData };
await persist();
return db.data.http;
}
function getAutomation(): Readonly<AutomationSettings> {
return db.data.automation;
}
@@ -165,8 +138,6 @@ async function mergeIntoData(newData: Partial<DatabaseModel>): ReadonlyPromise<D
db.data.settings = mergedData.settings;
db.data.viewSettings = mergedData.viewSettings;
db.data.automation = mergedData.automation;
db.data.osc = mergedData.osc;
db.data.http = mergedData.http;
db.data.urlPresets = mergedData.urlPresets;
db.data.customFields = mergedData.customFields;
db.data.rundown = mergedData.rundown;
apps/server/src/classes/data-provider/DataProvider.utils.ts
-2
View File
@@ -11,8 +11,6 @@ export function safeMerge(existing: DatabaseModel, newData: Partial<DatabaseMode
viewSettings = {},
urlPresets = existing.urlPresets,
customFields = existing.customFields,
osc = {},
http = {},
automation = existing.automation,
} = newData;
apps/server/src/classes/data-provider/__tests__/DataProvider.utils.test.ts
+6 -55
View File
@@ -35,18 +35,6 @@ describe('safeMerge', () => {
lighting: { type: 'string', label: 'lighting', colour: 'red' },
vfx: { type: 'string', label: 'vfx', colour: 'blue' },
},
osc: {
portIn: 8888,
portOut: 9999,
targetIP: '127.0.0.1',
enabledIn: false,
enabledOut: false,
subscriptions: [],
},
http: {
enabledOut: false,
subscriptions: [],
},
automation: {
enabledAutomations: false,
enabledOscIn: false,
@@ -107,38 +95,6 @@ describe('safeMerge', () => {
language: 'pt',
});
});
it('merges the osc key', () => {
const newData = {
osc: {
portIn: 7777,
subscriptions: [
{
id: 'unique',
cycle: 'onStart',
message: 'new message',
enabled: true,
},
],
},
};
//@ts-expect-error -- testing partial merge
const mergedData = safeMerge(existing, newData);
expect(mergedData.osc).toMatchObject({
portIn: 7777,
portOut: 9999,
targetIP: '127.0.0.1',
enabledIn: false,
enabledOut: false,
subscriptions: [
{
id: 'unique',
cycle: 'onStart',
message: 'new message',
enabled: true,
},
],
});
});
it('should merge the urlPresets key when present', () => {
const existingData = {
@@ -167,17 +123,12 @@ describe('safeMerge', () => {
} as ViewSettings,
urlPresets: [],
customFields: {},
osc: {
portIn: 8888,
portOut: 9999,
targetIP: '127.0.0.1',
enabledIn: false,
enabledOut: false,
subscriptions: [],
},
http: {
enabledOut: false,
subscriptions: [],
automation: {
enabledAutomations: false,
enabledOscIn: false,
oscPortIn: 8000,
automations: [],
blueprints: {},
},
} as DatabaseModel;
apps/server/src/models/dataModel.ts
-12
View File
@@ -31,18 +31,6 @@ export const dbModel: DatabaseModel = {
},
urlPresets: [],
customFields: {},
osc: {
portIn: 8888,
portOut: 9999,
targetIP: '127.0.0.1',
enabledIn: false,
enabledOut: false,
subscriptions: [],
},
http: {
enabledOut: false,
subscriptions: [],
},
automation: {
enabledAutomations: true,
enabledOscIn: true,
apps/server/src/models/demoProject.ts
-12
View File
@@ -450,18 +450,6 @@ export const demoDb: DatabaseModel = {
pathAndParams: 'lower?bg=ff2&text=f00&size=0.6&transition=5',
},
],
osc: {
portIn: 8888,
portOut: 9999,
targetIP: '127.0.0.1',
enabledIn: true,
enabledOut: false,
subscriptions: [],
},
http: {
enabledOut: false,
subscriptions: [],
},
automation: {
enabledAutomations: false,
enabledOscIn: true,
apps/server/src/services/integration-service/HttpIntegration.ts
-80
View File
@@ -1,80 +0,0 @@
import got from 'got';
import { HttpSettings, HttpSubscription, LogOrigin } from 'ontime-types';
import IIntegration, { TimerLifeCycleKey } from './IIntegration.js';
import { parseTemplateNested } from './integrationUtils.js';
import { logger } from '../../classes/Logger.js';
/**
* @description Class contains logic towards outgoing HTTP communications
* @class
*/
export class HttpIntegration implements IIntegration<HttpSubscription, HttpSettings> {
subscriptions: HttpSubscription[];
enabled: boolean;
constructor() {
this.subscriptions = [];
this.enabled = false;
}
/**
* Initializes httpClient
*/
init(config: HttpSettings) {
const { subscriptions, enabledOut } = config;
this.initSubscriptions(subscriptions);
this.enabled = enabledOut;
}
initSubscriptions(subscriptions: HttpSubscription[]) {
this.subscriptions = subscriptions;
}
dispatch(action: TimerLifeCycleKey, state?: object) {
// noop
if (!this.enabled) {
return;
}
for (let i = 0; i < this.subscriptions.length; i++) {
const { cycle, message, enabled } = this.subscriptions[i];
if (cycle !== action || !enabled || !message) {
continue;
}
const parsedMessage = parseTemplateNested(message, state || {});
this.emit(parsedMessage);
}
}
emit(path: string) {
got.get(path, { retry: { limit: 0 } }).catch((err) => {
logger.warning(LogOrigin.Tx, `HTTP Integration: ${err.message}`);
if (err.code === 'ECONNREFUSED') {
logger.warning(LogOrigin.Tx, `HTTP Integration: '${err.code}' The server refused the connection`);
return;
}
if (err.code === 'ENOTFOUND') {
logger.warning(LogOrigin.Tx, `HTTP Integration: '${err.code}' DNS lookup failed`);
return;
}
if (err.code === 'ETIMEDOUT') {
logger.warning(LogOrigin.Tx, `HTTP Integration: '${err.code}' The connection timed out`);
return;
}
logger.warning(LogOrigin.Tx, `HTTP Integration: ${err.code}`);
});
}
shutdown() {
/** shutdown is a no-op here*/
}
}
export const httpIntegration = new HttpIntegration();
apps/server/src/services/integration-service/IIntegration.ts
-11
View File
@@ -1,11 +0,0 @@
import { TimerLifeCycle } from 'ontime-types';
export type TimerLifeCycleKey = keyof typeof TimerLifeCycle;
export default interface IIntegration<T, C> {
subscriptions: T[];
init: (config: C) => void;
dispatch: (action: TimerLifeCycleKey, state?: object) => void;
emit: (...args: never[]) => unknown;
shutdown: () => void;
}
apps/server/src/services/integration-service/IntegrationService.ts
-37
View File
@@ -1,37 +0,0 @@
import { LogOrigin } from 'ontime-types';
import IIntegration, { TimerLifeCycleKey } from './IIntegration.js';
import { eventStore } from '../../stores/EventStore.js';
import { logger } from '../../classes/Logger.js';
class IntegrationService {
private integrations: IIntegration<unknown, unknown>[];
constructor() {
this.integrations = [];
}
register(integrationService: IIntegration<unknown, unknown>) {
this.integrations.push(integrationService);
}
unregister(integrationService: IIntegration<unknown, unknown>) {
this.integrations = this.integrations.filter((int) => int !== integrationService);
}
dispatch(action: TimerLifeCycleKey) {
const state = eventStore.poll();
this.integrations.forEach((integration) => {
integration.dispatch(action, state);
});
}
shutdown() {
logger.info(LogOrigin.Tx, 'Shutdown Integrations');
this.integrations.forEach((integration) => {
integration.shutdown();
});
}
}
export const integrationService = new IntegrationService();
apps/server/src/services/integration-service/OscIntegration.ts
-147
View File
@@ -1,147 +0,0 @@
import { ArgumentType, Client, Message } from 'node-osc';
import { LogOrigin, MaybeNumber, MaybeString, OSCSettings, OscSubscription } from 'ontime-types';
import IIntegration, { TimerLifeCycleKey } from './IIntegration.js';
import { parseTemplateNested } from './integrationUtils.js';
import { logger } from '../../classes/Logger.js';
import { OscServer } from '../../adapters/OscAdapter.js';
import { stringToOSCArgs } from '../../utils/oscArgParser.js';
/**
* @description Class contains logic towards outgoing OSC communications
* @class
*/
export class OscIntegration implements IIntegration<OscSubscription, OSCSettings> {
protected oscClient: null | Client;
protected oscServer: OscServer | null = null;
subscriptions: OscSubscription[];
targetIP: MaybeString;
portOut: MaybeNumber;
portIn: MaybeNumber;
enabledOut: boolean;
enabledIn: boolean;
constructor() {
this.oscClient = null;
this.subscriptions = [];
this.targetIP = null;
this.portOut = null;
this.portIn = null;
this.enabledOut = false;
this.enabledIn = false;
}
/**
* Initializes oscClient
*/
init(config: OSCSettings) {
const { targetIP, portOut, subscriptions, enabledOut, enabledIn, portIn } = config;
this.initTX(enabledOut, targetIP, portOut, subscriptions);
this.initRX(enabledIn, portIn);
// return `OSC integration client connected to ${targetIP}:${portOut}`;
}
private initSubscriptions(subscriptions: OscSubscription[]) {
this.subscriptions = subscriptions;
}
dispatch(action: TimerLifeCycleKey, state?: object) {
// noop
if (!this.oscClient || !this.enabledOut) {
return;
}
for (let i = 0; i < this.subscriptions.length; i++) {
const { cycle, address, payload, enabled } = this.subscriptions[i];
if (cycle !== action || !enabled || !address) {
continue;
}
const parsedAddress = parseTemplateNested(address, state || {});
const parsedPayload = payload ? parseTemplateNested(payload, state || {}) : undefined;
const parsedArguments = stringToOSCArgs(parsedPayload);
try {
this.emit(parsedAddress, parsedArguments);
} catch (error) {
logger.error(LogOrigin.Tx, `OSC Integration: ${error}`);
}
}
}
emit(address: string, args: ArgumentType[]) {
if (!this.oscClient) {
return;
}
//TODO: Look into using bundles
const message = new Message(address);
message.append(args);
this.oscClient.send(message);
}
private initTX(enabledOut: boolean, targetIP: string, portOut: number, subscriptions: OscSubscription[]) {
this.initSubscriptions(subscriptions);
if (!enabledOut) {
this.targetIP = targetIP;
this.portOut = portOut;
this.enabledOut = enabledOut;
this.shutdownTX();
return;
}
if (this.oscClient && targetIP === this.targetIP && portOut === this.portOut) {
// nothing changed that would mean we need a new client
return;
}
this.targetIP = targetIP;
this.portOut = portOut;
this.enabledOut = enabledOut;
try {
this.oscClient = new Client(targetIP, portOut);
logger.info(LogOrigin.Tx, `Starting OSC Clint on port: ${portOut}`);
} catch (error) {
this.oscClient = null;
throw new Error(`Failed initialising OSC client: ${error}`);
}
}
private initRX(enabledIn: boolean, portIn: number) {
if (!enabledIn) {
this.shutdownRX();
return;
}
// Start OSC Server
logger.info(LogOrigin.Rx, `Starting OSC Server on port: ${portIn}`);
this.oscServer = new OscServer(portIn);
}
shutdown() {
this.shutdownTX();
this.shutdownRX();
}
private shutdownTX() {
if (this.oscClient) {
logger.info(LogOrigin.Tx, 'Shutting down OSC integration');
this.oscClient?.close();
this.oscClient = null;
}
}
private shutdownRX() {
if (this.oscServer) {
logger.info(LogOrigin.Rx, 'Shutting down OSC integration');
this.oscServer?.shutdown();
this.oscServer = null;
}
}
}
export const oscIntegration = new OscIntegration();
apps/server/src/services/integration-service/integrationUtils.test.ts
-169
View File
@@ -1,169 +0,0 @@
import { stringToOSCArgs } from '../../utils/oscArgParser.js';
import { parseTemplateNested } from './integrationUtils.js';
describe('parseTemplateNested()', () => {
it('parses string with a single-level variable name', () => {
const store = { timer: 10 };
const templateString = '/test/{{timer}}';
const result = parseTemplateNested(templateString, store);
expect(result).toEqual('/test/10');
});
it('parses string with a nested variable name', () => {
const store = { timer: { clock: 10 } };
const templateString = '/timer/{{timer.clock}}';
const result = parseTemplateNested(templateString, store);
expect(result).toEqual('/timer/10');
});
it('parses string with multiple variables', () => {
const mockState = { test1: 'that', test2: 'this' };
const testString = '{{test1}} should replace {{test2}}';
const expected = `${mockState.test1} should replace ${mockState.test2}`;
const result = parseTemplateNested(testString, mockState);
expect(result).toStrictEqual(expected);
});
it('correctly parses a string without templates', () => {
const testString = 'That should replace {test}';
const result = parseTemplateNested(testString, {});
expect(result).toStrictEqual(testString);
});
it('handles scenarios with missing variables', () => {
// by failing to provide a value, we give visibility to
// potential issues in the given string
const mockState = { test1: 'that', test2: 'this' };
const testString = '{{test1}} should replace {{test2}}, but not {{test3}}';
const expected = `${mockState.test1} should replace ${mockState.test2}, but not {{test3}}`;
const result = parseTemplateNested(testString, mockState);
expect(result).toStrictEqual(expected);
});
});
describe('parseNestedTemplate() -> resolveAliasData()', () => {
it('resolves data through callback', () => {
const data = {
not: {
so: {
easy: '3',
},
},
};
const aliases = {
easy: { key: 'not.so.easy', cb: (value: string) => `testing-${value}` },
};
const easyParse = parseTemplateNested('{{human.easy}}', data, aliases);
expect(easyParse).toBe('testing-3');
});
it('handles a mixed operation', () => {
const data = {
not: {
so: {
easy: '3',
},
},
other: {
value: 42,
},
};
const aliases = {
easy: { key: 'not.so.easy', cb: (value: string) => `testing-${value}` },
};
const easyParse = parseTemplateNested('{{other.value}} to {{human.easy}}', data, aliases);
expect(easyParse).toBe('42 to testing-3');
});
it('returns given key when not found', () => {
const data = {
not: {
so: {
easy: '3',
},
},
other: {
value: 5,
},
};
const aliases = {
easy: { key: 'not.so.easy', cb: (value: string) => `testing-${value}` },
};
const easyParse = parseTemplateNested('{{other.value}} to {{human.easy}} {{human.not.found}}', data, aliases);
expect(easyParse).toBe('5 to testing-3 {{human.not.found}}');
});
});
describe('parseNestedTemplate() -> stringToOSCArgs()', () => {
it('specific osc requirements', () => {
const data = {
not: {
so: {
easy: 'data with space',
empty: '',
number: 1234,
stringNumber: '1234',
},
},
};
const payloads = [
{
test: '"string with space and {{not.so.easy}}"',
expect: [{ type: 'string', value: 'string with space and data with space' }],
},
{
test: '',
expect: [],
},
{
test: ' ',
expect: [],
},
{
test: '""',
expect: [{ type: 'string', value: '' }],
},
{
test: '"string with space and {{not.so.empty}}"',
expect: [{ type: 'string', value: 'string with space and ' }],
},
{
test: '"string with space and {{not.so.number}}"',
expect: [{ type: 'string', value: 'string with space and 1234' }],
},
{
test: '"string with space and {{not.so.stringNumber}}"',
expect: [{ type: 'string', value: 'string with space and 1234' }],
},
{
test: '"{{not.so.easy}}" 1',
expect: [
{ type: 'string', value: 'data with space' },
{ type: 'integer', value: 1 },
],
},
{
test: '"{{not.so.empty}}" 1',
expect: [
{ type: 'string', value: '' },
{ type: 'integer', value: 1 },
],
},
{
test: '',
expect: [],
},
];
payloads.forEach((payload) => {
const parsedPayload = parseTemplateNested(payload.test, data);
const parsedArguments = stringToOSCArgs(parsedPayload);
expect(parsedArguments).toStrictEqual(payload.expect);
});
});
});
apps/server/src/services/integration-service/integrationUtils.ts
-73
View File
@@ -1,73 +0,0 @@
import { MaybeNumber } from 'ontime-types';
import { millisToString, removeLeadingZero } from 'ontime-utils';
// any value inside double curly braces {{val}}
const placeholderRegex = /{{(.*?)}}/g;
function formatDisplayFromString(value: string, hideZero = false): string {
let valueInNumber: MaybeNumber = null;
if (value !== 'null') {
const parsedValue = Number(value);
if (!Number.isNaN(parsedValue)) {
valueInNumber = parsedValue;
}
}
let formatted = millisToString(valueInNumber, { fallback: hideZero ? '00:00' : '00:00:00' });
if (hideZero) {
formatted = removeLeadingZero(formatted);
}
return formatted;
}
type AliasesDefinition = Record<string, { key: string; cb: (value: string) => string }>;
const quickAliases: AliasesDefinition = {
clock: { key: 'clock', cb: (value: string) => formatDisplayFromString(value) },
duration: { key: 'timer.duration', cb: (value: string) => formatDisplayFromString(value, true) },
expectedEnd: {
key: 'timer.expectedFinish',
cb: (value: string) => formatDisplayFromString(value),
},
runningTimer: {
key: 'timer.current',
cb: (value: string) => formatDisplayFromString(value, true),
},
elapsedTime: {
key: 'timer.elapsed',
cb: (value: string) => formatDisplayFromString(value, true),
},
startedAt: { key: 'timer.startedAt', cb: (value: string) => formatDisplayFromString(value) },
};
/**
* Parses a templated string to values in a nested object
*/
export function parseTemplateNested(template: string, state: object, humanReadable = quickAliases): string {
let parsedTemplate = template;
const matches = Array.from(parsedTemplate.matchAll(placeholderRegex));
for (const match of matches) {
const variableName = match[1];
const variableParts = variableName.split('.');
let value: string | undefined = undefined;
if (variableParts[0] === 'human') {
const lookupKey = variableParts[1];
if (lookupKey in humanReadable) {
const newTemplate = `{{${humanReadable[lookupKey].key}}}`;
const parsed = parseTemplateNested(newTemplate, state, humanReadable);
value = humanReadable[lookupKey].cb(parsed);
} else {
value = undefined;
}
} else {
// iterate through variable parts, and look for the property in the state object
value = variableParts.reduce((obj, key) => obj?.[key], state);
}
if (value !== undefined) {
parsedTemplate = parsedTemplate.replace(match[0], value);
}
}
return parsedTemplate;
}
apps/server/src/services/project-service/ProjectService.ts
+2 -12
View File
@@ -28,8 +28,6 @@ import {
setLastLoadedProject,
} from '../app-state-service/AppStateService.js';
import { runtimeService } from '../runtime-service/RuntimeService.js';
import { oscIntegration } from '../integration-service/OscIntegration.js';
import { httpIntegration } from '../integration-service/HttpIntegration.js';
import {
copyCorruptFile,
@@ -176,14 +174,10 @@ export async function loadProjectFile(name: string) {
// apply data model
runtimeService.stop();
const { rundown, customFields, osc, http } = result.data;
const { rundown, customFields } = result.data;
// apply the rundown
await initRundown(rundown, customFields);
// apply integrations
oscIntegration.init(osc);
httpIntegration.init(http);
}
/**
@@ -250,14 +244,10 @@ export async function renameProjectFile(originalFile: string, newFilename: strin
// apply data model
runtimeService.stop();
const { rundown, customFields, osc, http } = result.data;
const { rundown, customFields } = result.data;
// apply the rundown
await initRundown(rundown, customFields);
// apply integrations
oscIntegration.init(osc);
httpIntegration.init(http);
}
}
apps/server/src/services/runtime-service/RuntimeService.ts
-1
View File
@@ -32,7 +32,6 @@ import {
getRundown,
getTimedEvents,
} from '../rundown-service/rundownUtils.js';
import { integrationService } from '../integration-service/IntegrationService.js';
import { getForceUpdate, getShouldClockUpdate, getShouldTimerUpdate } from './rundownService.utils.js';
import { skippedOutOfEvent } from '../timerUtils.js';
apps/server/src/utils/__tests__/parser.test.ts
+1 -3
View File
@@ -314,7 +314,7 @@ describe('test parser edge cases', () => {
//@ts-expect-error -- we know this is wrong, testing imports outside domain
const { data, errors } = parseDatabaseModel(testData);
expect(data.rundown.length).toBe(1);
expect(errors.length).toBe(7);
expect(errors.length).toBe(5);
});
it('handles incomplete datasets', () => {
@@ -724,8 +724,6 @@ describe('test import of v2 datamodel', () => {
);
// @ts-expect-error -- checking if the field is removed
expect(parsed?.userFields).toBeUndefined();
expect(parsed.osc).toMatchObject({ subscriptions: [] });
expect(parsed.http).toMatchObject({ enabledOut: false, subscriptions: [] });
});
});
apps/server/src/utils/__tests__/parserFunctions.test.ts
-143
View File
@@ -2,12 +2,8 @@ import {
CustomFields,
DatabaseModel,
EndAction,
HttpSettings,
HttpSubscription,
OSCSettings,
OntimeEvent,
OntimeRundown,
OscSubscription,
Settings,
SupportedEvent,
TimeStrategy,
@@ -17,16 +13,12 @@ import {
import {
parseCustomFields,
parseHttp,
parseOsc,
parseProject,
parseRundown,
parseSettings,
parseUrlPresets,
parseViewSettings,
sanitiseCustomFields,
sanitiseHttpSubscriptions,
sanitiseOscSubscriptions,
} from '../parserFunctions.js';
describe('parseRundown()', () => {
@@ -111,66 +103,6 @@ describe('parseViewSettings()', () => {
});
});
describe('parseOsc()', () => {
it('returns an a base model if nothing is given', () => {
const errorEmitter = vi.fn();
const result = parseOsc({}, errorEmitter);
expect(result).toBeTypeOf('object');
expect(errorEmitter).toHaveBeenCalledOnce();
});
it('parses data, skipping invalid results', () => {
const errorEmitter = vi.fn();
const osc = {
subscriptions: [
{ id: '1', cycle: 'onLoad', address: '/test', payload: 'test', enabled: true }, // OK
{}, // no data
{ id: '2', cycle: 'onStart', payload: 'test', enabled: true }, // no address
],
} as OSCSettings;
const result = parseOsc({ osc }, errorEmitter);
expect(result.subscriptions.length).toEqual(1);
expect(result.subscriptions.at(0)).toMatchObject({
id: '1',
cycle: 'onLoad',
address: '/test',
payload: 'test',
enabled: true,
});
expect(errorEmitter).toHaveBeenCalled();
});
});
describe('parseHttp()', () => {
it('returns an a base model if nothing is given', () => {
const errorEmitter = vi.fn();
const result = parseHttp({}, errorEmitter);
expect(result).toBeTypeOf('object');
expect(errorEmitter).toHaveBeenCalledOnce();
});
it('parses data, skipping invalid results', () => {
const errorEmitter = vi.fn();
const http = {
subscriptions: [
{ id: '1', cycle: 'onLoad', message: 'http://', enabled: true }, // OK
{}, // no data
{ id: '2', cycle: 'onStart', enabled: true }, // no message
{ id: '3', cycle: 'onLoad', message: '/test', enabled: true }, // doesnt start with http
],
} as HttpSettings;
const result = parseHttp({ http }, errorEmitter);
expect(result.subscriptions.length).toEqual(1);
expect(result.subscriptions.at(0)).toMatchObject({
id: '1',
cycle: 'onLoad',
message: 'http://',
enabled: true,
});
expect(errorEmitter).toHaveBeenCalled();
});
});
describe('parseUrlPresets()', () => {
it('returns an a base model if nothing is given', () => {
const errorEmitter = vi.fn();
@@ -223,81 +155,6 @@ describe('parseCustomFields()', () => {
});
});
describe('sanitiseOscSubscriptions()', () => {
it('throws if not an array an empty array if not an array', () => {
expect(() => sanitiseOscSubscriptions(undefined)).toThrow();
// @ts-expect-error -- data is external, we check bad types
expect(() => sanitiseOscSubscriptions({})).toThrow();
expect(() => sanitiseOscSubscriptions(null)).toThrow();
});
it('returns an array of valid entries', () => {
const oscSubscriptions: OscSubscription[] = [
{ id: '1', cycle: 'onLoad', address: '/test', payload: 'test', enabled: true },
{ id: '2', cycle: 'onStart', address: '/test', payload: 'test', enabled: false },
{ id: '3', cycle: 'onPause', address: '/test', payload: 'test', enabled: true },
{ id: '4', cycle: 'onStop', address: '/test', payload: 'test', enabled: false },
{ id: '5', cycle: 'onUpdate', address: '/test', payload: 'test', enabled: true },
{ id: '6', cycle: 'onFinish', address: '/test', payload: 'test', enabled: false },
{ id: '7', cycle: 'onWarning', address: '/test', payload: 'test', enabled: false },
{ id: '8', cycle: 'onDanger', address: '/test', payload: 'test', enabled: false },
];
const sanitationResult = sanitiseOscSubscriptions(oscSubscriptions);
expect(sanitationResult).toStrictEqual(oscSubscriptions);
});
it('filters invalid entries', () => {
const oscSubscriptions = [
{ id: '1', cycle: 'onLoad', address: 4, payload: 'test', enabled: true },
{ cycle: 'onLoad', payload: 'test', enabled: true },
{ id: '2', cycle: 'unknown', payload: 'test', enabled: false },
{ id: '3', payload: 'test', enabled: true },
{ id: '4', cycle: 'onStop', enabled: false },
{ id: '5', cycle: 'onUpdate', payload: 'test' },
{ id: '6', cycle: 'onFinish', payload: 'test', enabled: 'true' },
] as OscSubscription[];
const sanitationResult = sanitiseOscSubscriptions(oscSubscriptions);
expect(sanitationResult.length).toBe(0);
});
});
describe('sanitiseHttpSubscriptions()', () => {
it('throws if the data is unexpected', () => {
expect(() => sanitiseHttpSubscriptions(undefined)).toThrow();
// @ts-expect-error -- data is external, we check bad types
expect(() => sanitiseHttpSubscriptions({})).toThrow();
expect(() => sanitiseHttpSubscriptions(null)).toThrow();
});
it('returns an array of valid entries', () => {
const httpSubscription: HttpSubscription[] = [
{ id: '1', cycle: 'onLoad', message: 'http://test', enabled: true },
{ id: '2', cycle: 'onStart', message: 'http://test', enabled: false },
{ id: '3', cycle: 'onPause', message: 'http://test', enabled: true },
{ id: '4', cycle: 'onStop', message: 'http://test', enabled: false },
{ id: '5', cycle: 'onUpdate', message: 'http://test', enabled: true },
{ id: '6', cycle: 'onFinish', message: 'http://test', enabled: false },
{ id: '7', cycle: 'onWarning', message: 'http://test', enabled: false },
{ id: '8', cycle: 'onDanger', message: 'http://test', enabled: false },
];
const sanitationResult = sanitiseHttpSubscriptions(httpSubscription);
expect(sanitationResult).toStrictEqual(httpSubscription);
});
it('filters invalid entries', () => {
const httpSubscription = [
{ cycle: 'onLoad', message: 'http://test', enabled: true },
{ id: '2', cycle: 'unknown', message: 'http://test', enabled: false },
{ id: '3', message: 'http://test', enabled: true },
{ id: '4', cycle: 'onStop', enabled: false },
{ id: '5', cycle: 'onUpdate', message: 'http://test' },
{ id: '6', cycle: 'onFinish', message: 'ftp://test', enabled: 'true' },
];
const sanitationResult = sanitiseHttpSubscriptions(httpSubscription as HttpSubscription[]);
expect(sanitationResult.length).toBe(0);
});
});
describe('sanitiseCustomFields()', () => {
it('returns an empty array if not an array', () => {
expect(sanitiseCustomFields({})).toEqual({});
apps/server/src/utils/parser.ts
+1 -11
View File
@@ -27,15 +27,7 @@ import { logger } from '../classes/Logger.js';
import { event as eventDef } from '../models/eventsDefinition.js';
import { makeString } from './parserUtils.js';
import {
parseHttp,
parseOsc,
parseProject,
parseRundown,
parseSettings,
parseUrlPresets,
parseViewSettings,
} from './parserFunctions.js';
import { parseProject, parseRundown, parseSettings, parseUrlPresets, parseViewSettings } from './parserFunctions.js';
import { parseExcelDate } from './time.js';
export type ErrorEmitter = (message: string) => void;
@@ -334,8 +326,6 @@ export function parseDatabaseModel(jsonData: Partial<DatabaseModel>): { data: Da
viewSettings: parseViewSettings(jsonData, makeEmitError('View Settings')),
urlPresets: parseUrlPresets(jsonData, makeEmitError('URL Presets')),
customFields,
osc: parseOsc(jsonData, makeEmitError('OSC')),
http: parseHttp(jsonData, makeEmitError('HTTP')),
automation: parseAutomationSettings(jsonData),
};
apps/server/src/utils/parserFunctions.ts
+1 -102
View File
@@ -2,25 +2,20 @@ import {
CustomField,
CustomFields,
DatabaseModel,
HttpSettings,
HttpSubscription,
OSCSettings,
OntimeBlock,
OntimeDelay,
OntimeEvent,
OntimeRundown,
OscSubscription,
ProjectData,
Settings,
TimerType,
URLPreset,
ViewSettings,
isOntimeBlock,
isOntimeCycle,
isOntimeDelay,
isOntimeEvent,
} from 'ontime-types';
import { customFieldLabelToKey, generateId, getErrorMessage, isAlphanumericWithSpace } from 'ontime-utils';
import { customFieldLabelToKey, generateId, isAlphanumericWithSpace } from 'ontime-utils';
import { dbModel } from '../models/dataModel.js';
import { block as blockDef, delay as delayDef } from '../models/eventsDefinition.js';
@@ -165,102 +160,6 @@ export function parseViewSettings(data: Partial<DatabaseModel>, emitError?: Erro
};
}
/**
* Sanitises an OSC Subscriptions array
*/
export function sanitiseOscSubscriptions(subscriptions?: OscSubscription[]): OscSubscription[] {
if (!Array.isArray(subscriptions)) {
throw new Error('ERROR: invalid OSC subscriptions');
}
return subscriptions.filter(
({ id, cycle, address, payload, enabled }) =>
typeof id === 'string' &&
isOntimeCycle(cycle) &&
typeof address === 'string' &&
typeof payload === 'string' &&
typeof enabled === 'boolean',
);
}
/**
* Parse osc portion of an entry
*/
export function parseOsc(data: Partial<DatabaseModel>, emitError?: ErrorEmitter): OSCSettings {
if (!data.osc) {
emitError?.('No data found to import');
return { ...dbModel.osc };
}
console.log('Found OSC settings, importing...');
let newSubscriptions: OscSubscription[] = [];
try {
newSubscriptions = sanitiseOscSubscriptions(data.osc.subscriptions);
} catch (error) {
emitError?.(getErrorMessage(error));
}
if (newSubscriptions.length !== data.osc.subscriptions.length) {
emitError?.('Skipped invalid subscriptions');
}
return {
portIn: data.osc.portIn ?? dbModel.osc.portIn,
portOut: data.osc.portOut ?? dbModel.osc.portOut,
targetIP: data.osc.targetIP ?? dbModel.osc.targetIP,
enabledIn: data.osc.enabledIn ?? dbModel.osc.enabledIn,
enabledOut: data.osc.enabledOut ?? dbModel.osc.enabledOut,
subscriptions: newSubscriptions,
};
}
/**
* Sanitises an HTTP Subscriptions array
*/
export function sanitiseHttpSubscriptions(subscriptions?: HttpSubscription[]): HttpSubscription[] {
if (!Array.isArray(subscriptions)) {
throw new Error('ERROR: invalid HTTP subscriptions');
}
return subscriptions.filter(
({ id, cycle, message, enabled }) =>
typeof id === 'string' &&
isOntimeCycle(cycle) &&
typeof message === 'string' &&
message.startsWith('http://') &&
typeof enabled === 'boolean',
);
}
/**
* Parse Http portion of an entry
*/
export function parseHttp(data: Partial<DatabaseModel>, emitError?: ErrorEmitter): HttpSettings {
if (!data.http) {
emitError?.('No data found to import');
return { ...dbModel.http };
}
console.log('Found HTTP settings, importing...');
let newSubscriptions: HttpSubscription[] = [];
try {
newSubscriptions = sanitiseHttpSubscriptions(data.http.subscriptions);
} catch (error) {
emitError?.(getErrorMessage(error));
}
if (newSubscriptions.length !== data.http?.subscriptions.length) {
emitError?.('Skipped invalid subscriptions');
}
return {
enabledOut: data.http.enabledOut ?? dbModel.http.enabledOut,
subscriptions: newSubscriptions,
};
}
/**
* Parse URL preset portion of an entry
*/