mirror of
https://github.com/cpvalente/ontime.git
synced 2026-07-26 10:38:55 +00:00
refactor: implement operations on nested events
This commit is contained in:
Carlos Valente
arc-alex
@@ -4,6 +4,7 @@ import {
|
||||
EntryId,
|
||||
isOntimeEvent,
|
||||
MaybeString,
|
||||
OntimeBlock,
|
||||
OntimeEntry,
|
||||
OntimeEvent,
|
||||
Rundown,
|
||||
@@ -11,7 +12,7 @@ import {
|
||||
TimeStrategy,
|
||||
TransientEventPayload,
|
||||
} from 'ontime-types';
|
||||
import { dayInMs, MILLIS_PER_SECOND, parseUserTime, reorderArray, swapEventData } from 'ontime-utils';
|
||||
import { dayInMs, generateId, MILLIS_PER_SECOND, parseUserTime, reorderArray, swapEventData } from 'ontime-utils';
|
||||
|
||||
import { RUNDOWN } from '../api/constants';
|
||||
import {
|
||||
@@ -71,6 +72,7 @@ export const useEntryActions = () => {
|
||||
* @private
|
||||
*/
|
||||
const _addEntryMutation = useMutation({
|
||||
// TODO(v4): optimistic create entry
|
||||
mutationFn: postAddEntry,
|
||||
onSettled: () => {
|
||||
queryClient.invalidateQueries({ queryKey: RUNDOWN });
|
||||
@@ -83,7 +85,7 @@ export const useEntryActions = () => {
|
||||
*/
|
||||
const addEntry = useCallback(
|
||||
async (entry: Partial<OntimeEntry>, options?: EventOptions) => {
|
||||
const newEntry: TransientEventPayload = { ...entry };
|
||||
const newEntry: TransientEventPayload = { ...entry, id: generateId() };
|
||||
|
||||
// ************* CHECK OPTIONS specific to events
|
||||
if (isOntimeEvent(newEntry)) {
|
||||
@@ -188,6 +190,7 @@ export const useEntryActions = () => {
|
||||
id: previousData.id,
|
||||
title: previousData.title,
|
||||
order: previousData.order,
|
||||
flatOrder: previousData.flatOrder,
|
||||
entries: newRundown,
|
||||
revision: -1,
|
||||
});
|
||||
@@ -355,6 +358,7 @@ export const useEntryActions = () => {
|
||||
id: previousRundown.id,
|
||||
title: previousRundown.title,
|
||||
order: previousRundown.order,
|
||||
flatOrder: previousRundown.flatOrder,
|
||||
entries: newRundown,
|
||||
revision: -1,
|
||||
});
|
||||
@@ -399,17 +403,14 @@ export const useEntryActions = () => {
|
||||
|
||||
if (previousData) {
|
||||
// optimistically update object
|
||||
const newOrder = previousData.order.filter((id) => !entryIds.includes(id));
|
||||
const newRundown = { ...previousData.entries };
|
||||
for (const eventId of entryIds) {
|
||||
delete newRundown[eventId];
|
||||
}
|
||||
const { entries, order, flatOrder } = optimisticDeleteEntries(entryIds, previousData);
|
||||
|
||||
queryClient.setQueryData<Rundown>(RUNDOWN, {
|
||||
id: previousData.id,
|
||||
title: previousData.title,
|
||||
order: newOrder,
|
||||
entries: newRundown,
|
||||
order,
|
||||
flatOrder,
|
||||
entries,
|
||||
revision: -1,
|
||||
});
|
||||
}
|
||||
@@ -462,8 +463,9 @@ export const useEntryActions = () => {
|
||||
queryClient.setQueryData<Rundown>(RUNDOWN, {
|
||||
id: previousData?.id ?? 'default',
|
||||
title: previousData?.title ?? '',
|
||||
entries: {},
|
||||
order: [],
|
||||
flatOrder: [],
|
||||
entries: {},
|
||||
revision: -1,
|
||||
});
|
||||
|
||||
@@ -542,6 +544,7 @@ export const useEntryActions = () => {
|
||||
id: previousData.id,
|
||||
title: previousData.title,
|
||||
order: newOrder,
|
||||
flatOrder: previousData.flatOrder,
|
||||
entries: previousData.entries,
|
||||
revision: -1,
|
||||
});
|
||||
@@ -613,6 +616,7 @@ export const useEntryActions = () => {
|
||||
id: previousData.id,
|
||||
title: previousData.title,
|
||||
order: previousData.order,
|
||||
flatOrder: previousData.flatOrder,
|
||||
entries: newRundown,
|
||||
revision: -1,
|
||||
});
|
||||
@@ -662,3 +666,32 @@ export const useEntryActions = () => {
|
||||
updateCustomField,
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* Utility to optimistically delete entries from client cache
|
||||
*/
|
||||
function optimisticDeleteEntries(entryIds: EntryId[], rundown: Rundown) {
|
||||
const entries = { ...rundown.entries };
|
||||
let order = [...rundown.order];
|
||||
let flatOrder = [...rundown.flatOrder];
|
||||
|
||||
for (let i = 0; i < entryIds.length; i++) {
|
||||
const entry = entries[entryIds[i]];
|
||||
deleteEntry(entry);
|
||||
}
|
||||
|
||||
function deleteEntry(entry: OntimeEntry) {
|
||||
if (isOntimeEvent(entry) && entry.parent) {
|
||||
const parent = entries[entry.parent] as OntimeBlock;
|
||||
parent.events = parent.events.filter((event) => event !== entry.id);
|
||||
parent.numEvents -= 1;
|
||||
} else {
|
||||
order = order.filter((id) => id !== entry.id);
|
||||
}
|
||||
|
||||
delete entries[entry.id];
|
||||
flatOrder = flatOrder.filter((id) => id !== entry.id);
|
||||
}
|
||||
|
||||
return { entries, order, flatOrder };
|
||||
}
|
||||
|
||||
@@ -8,6 +8,7 @@ import {
|
||||
type Rundown,
|
||||
isOntimeBlock,
|
||||
isOntimeEvent,
|
||||
OntimeEntry,
|
||||
Playback,
|
||||
SupportedEvent,
|
||||
} from 'ontime-types';
|
||||
@@ -93,7 +94,7 @@ export default function Rundown({ data }: RundownProps) {
|
||||
);
|
||||
|
||||
const insertAtId = useCallback(
|
||||
(type: SupportedEvent, id: MaybeString, above = false) => {
|
||||
(patch: Partial<OntimeEntry> & { type: SupportedEvent }, id: MaybeString, above = false) => {
|
||||
const options: EventOptions =
|
||||
id === null
|
||||
? {}
|
||||
@@ -102,17 +103,10 @@ export default function Rundown({ data }: RundownProps) {
|
||||
before: above ? id : undefined,
|
||||
};
|
||||
|
||||
if (type === SupportedEvent.Event) {
|
||||
const newEvent = {
|
||||
type: SupportedEvent.Event,
|
||||
};
|
||||
if (!above && id) {
|
||||
options.lastEventId = id;
|
||||
}
|
||||
addEntry(newEvent, options);
|
||||
} else {
|
||||
addEntry({ type }, options);
|
||||
if (!above && id) {
|
||||
options.lastEventId = id;
|
||||
}
|
||||
addEntry(patch, options);
|
||||
},
|
||||
[addEntry],
|
||||
);
|
||||
@@ -208,14 +202,14 @@ export default function Rundown({ data }: RundownProps) {
|
||||
|
||||
['mod + Backspace', () => deleteAtCursor(cursor), { preventDefault: true }],
|
||||
|
||||
['alt + E', () => insertAtId(SupportedEvent.Event, cursor), { preventDefault: true }],
|
||||
['alt + shift + E', () => insertAtId(SupportedEvent.Event, cursor, true), { preventDefault: true }],
|
||||
['alt + E', () => insertAtId({ type: SupportedEvent.Event }, cursor), { preventDefault: true }],
|
||||
['alt + shift + E', () => insertAtId({ type: SupportedEvent.Event }, cursor, true), { preventDefault: true }],
|
||||
|
||||
['alt + B', () => insertAtId(SupportedEvent.Block, cursor), { preventDefault: true }],
|
||||
['alt + shift + B', () => insertAtId(SupportedEvent.Block, cursor, true), { preventDefault: true }],
|
||||
['alt + B', () => insertAtId({ type: SupportedEvent.Block }, cursor), { preventDefault: true }],
|
||||
['alt + shift + B', () => insertAtId({ type: SupportedEvent.Block }, cursor, true), { preventDefault: true }],
|
||||
|
||||
['alt + D', () => insertAtId(SupportedEvent.Delay, cursor), { preventDefault: true }],
|
||||
['alt + shift + D', () => insertAtId(SupportedEvent.Delay, cursor, true), { preventDefault: true }],
|
||||
['alt + D', () => insertAtId({ type: SupportedEvent.Delay }, cursor), { preventDefault: true }],
|
||||
['alt + shift + D', () => insertAtId({ type: SupportedEvent.Delay }, cursor, true), { preventDefault: true }],
|
||||
|
||||
['mod + C', () => setEntryCopyId(cursor)],
|
||||
['mod + V', () => insertCopyAtId(cursor, entryCopyId)],
|
||||
@@ -260,7 +254,7 @@ export default function Rundown({ data }: RundownProps) {
|
||||
};
|
||||
|
||||
if (statefulEntries.length < 1) {
|
||||
return <RundownEmpty handleAddNew={() => insertAtId(SupportedEvent.Event, cursor)} />;
|
||||
return <RundownEmpty handleAddNew={() => insertAtId({ type: SupportedEvent.Event }, cursor)} />;
|
||||
}
|
||||
|
||||
// 1. gather presentation options
|
||||
@@ -292,15 +286,21 @@ export default function Rundown({ data }: RundownProps) {
|
||||
return (
|
||||
<Fragment key={entry.id}>
|
||||
{isEditMode && (hasCursor || isFirst) && (
|
||||
<QuickAddBlock showBlocks previousEventId={rundownMeta.previousEntryId} />
|
||||
<QuickAddBlock previousEventId={rundownMeta.previousEntryId} parentBlock={null} />
|
||||
)}
|
||||
{isOntimeBlock(entry) ? (
|
||||
<BlockBlock data={entry} hasCursor={hasCursor}>
|
||||
{entry.events.length === 0 && (
|
||||
<BlockEmpty handleAddNew={() => insertAtId(SupportedEvent.Event, cursor)} />
|
||||
<BlockEmpty
|
||||
handleAddNew={() => insertAtId({ type: SupportedEvent.Event, parent: entry.id }, entry.id)}
|
||||
/>
|
||||
)}
|
||||
{entry.events.map((eventId, nestedIndex) => {
|
||||
const nestedEntry = entries[eventId];
|
||||
if (!nestedEntry) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const nestedRundownMeta = process(nestedEntry);
|
||||
const isFirstInGroup = nestedIndex === 0;
|
||||
const isLastInGroup = nestedIndex === entry.events.length - 1;
|
||||
@@ -312,7 +312,10 @@ export default function Rundown({ data }: RundownProps) {
|
||||
return (
|
||||
<Fragment key={nestedEntry.id}>
|
||||
{isEditMode && (hasNestedCursor || isFirstInGroup) && (
|
||||
<QuickAddBlock previousEventId={rundownMeta.previousEntryId} />
|
||||
<QuickAddBlock
|
||||
parentBlock={entry.id}
|
||||
previousEventId={nestedRundownMeta.previousEntryId}
|
||||
/>
|
||||
)}
|
||||
|
||||
<div
|
||||
@@ -342,7 +345,7 @@ export default function Rundown({ data }: RundownProps) {
|
||||
</div>
|
||||
</div>
|
||||
{isEditMode && (hasNestedCursor || isLastInGroup) && (
|
||||
<QuickAddBlock previousEventId={entry.id} />
|
||||
<QuickAddBlock parentBlock={entry.id} previousEventId={nestedEntry.id} />
|
||||
)}
|
||||
</Fragment>
|
||||
);
|
||||
@@ -371,7 +374,9 @@ export default function Rundown({ data }: RundownProps) {
|
||||
</div>
|
||||
</div>
|
||||
)}
|
||||
{isEditMode && (hasCursor || isLast) && <QuickAddBlock showBlocks previousEventId={entry.id} />}
|
||||
{isEditMode && (hasCursor || isLast) && (
|
||||
<QuickAddBlock previousEventId={entry.id} parentBlock={null} />
|
||||
)}
|
||||
</Fragment>
|
||||
);
|
||||
})}
|
||||
|
||||
@@ -5,6 +5,7 @@
|
||||
|
||||
margin: 0.25rem 0;
|
||||
font-size: calc(1rem - 3px);
|
||||
margin-left: calc(2em + 0.5rem);
|
||||
}
|
||||
|
||||
.quickBtn {
|
||||
|
||||
@@ -1,74 +1,69 @@
|
||||
import { memo, useCallback, useRef } from 'react';
|
||||
import { memo, useRef } from 'react';
|
||||
import { IoAdd } from 'react-icons/io5';
|
||||
import { Button } from '@chakra-ui/react';
|
||||
import { MaybeString, SupportedEvent } from 'ontime-types';
|
||||
|
||||
import { useEntryActions } from '../../../common/hooks/useEntryAction';
|
||||
import { useEmitLog } from '../../../common/stores/logger';
|
||||
|
||||
import style from './QuickAddBlock.module.scss';
|
||||
|
||||
interface QuickAddBlockProps {
|
||||
previousEventId: MaybeString;
|
||||
showBlocks?: boolean;
|
||||
parentBlock: MaybeString;
|
||||
}
|
||||
|
||||
export default memo(QuickAddBlock);
|
||||
|
||||
function QuickAddBlock(props: QuickAddBlockProps) {
|
||||
const { previousEventId, showBlocks } = props;
|
||||
const { previousEventId, parentBlock } = props;
|
||||
const { addEntry } = useEntryActions();
|
||||
const { emitError } = useEmitLog();
|
||||
|
||||
const doLinkPrevious = useRef<HTMLInputElement | null>(null);
|
||||
const doPublic = useRef<HTMLInputElement | null>(null);
|
||||
|
||||
const handleCreateEvent = useCallback(
|
||||
(eventType: SupportedEvent) => {
|
||||
switch (eventType) {
|
||||
case 'event': {
|
||||
const defaultPublic = doPublic?.current?.checked;
|
||||
const linkPrevious = doLinkPrevious?.current?.checked;
|
||||
const addEvent = () => {
|
||||
addEntry(
|
||||
{
|
||||
type: SupportedEvent.Event,
|
||||
parent: parentBlock ?? null,
|
||||
},
|
||||
{
|
||||
after: previousEventId,
|
||||
defaultPublic: doPublic?.current?.checked,
|
||||
lastEventId: previousEventId,
|
||||
linkPrevious: doLinkPrevious?.current?.checked,
|
||||
},
|
||||
);
|
||||
};
|
||||
|
||||
const newEvent = { type: SupportedEvent.Event };
|
||||
const options = {
|
||||
after: previousEventId,
|
||||
defaultPublic,
|
||||
lastEventId: previousEventId,
|
||||
linkPrevious,
|
||||
};
|
||||
addEntry(newEvent, options);
|
||||
break;
|
||||
}
|
||||
case 'delay': {
|
||||
const options = {
|
||||
lastEventId: previousEventId,
|
||||
after: previousEventId,
|
||||
};
|
||||
addEntry({ type: SupportedEvent.Delay }, options);
|
||||
break;
|
||||
}
|
||||
case 'block': {
|
||||
const options = {
|
||||
lastEventId: previousEventId,
|
||||
after: previousEventId,
|
||||
};
|
||||
addEntry({ type: SupportedEvent.Block }, options);
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
emitError(`Cannot create unknown event type: ${eventType}`);
|
||||
break;
|
||||
}
|
||||
}
|
||||
},
|
||||
[previousEventId, addEntry, emitError],
|
||||
);
|
||||
const addDelay = () => {
|
||||
addEntry(
|
||||
// TODO(v4): add delays to blocks
|
||||
{ type: SupportedEvent.Delay },
|
||||
{
|
||||
lastEventId: previousEventId,
|
||||
after: previousEventId,
|
||||
},
|
||||
);
|
||||
};
|
||||
|
||||
const addBlock = () => {
|
||||
if (parentBlock !== null) {
|
||||
return;
|
||||
}
|
||||
addEntry(
|
||||
{ type: SupportedEvent.Block },
|
||||
{
|
||||
lastEventId: previousEventId,
|
||||
after: previousEventId,
|
||||
},
|
||||
);
|
||||
};
|
||||
|
||||
return (
|
||||
<div className={style.quickAdd}>
|
||||
<Button
|
||||
onClick={() => handleCreateEvent(SupportedEvent.Event)}
|
||||
onClick={addEvent}
|
||||
size='xs'
|
||||
variant='ontime-subtle-white'
|
||||
className={style.quickBtn}
|
||||
@@ -78,7 +73,7 @@ function QuickAddBlock(props: QuickAddBlockProps) {
|
||||
Event
|
||||
</Button>
|
||||
<Button
|
||||
onClick={() => handleCreateEvent(SupportedEvent.Delay)}
|
||||
onClick={addDelay}
|
||||
size='xs'
|
||||
variant='ontime-subtle-white'
|
||||
className={style.quickBtn}
|
||||
@@ -87,9 +82,9 @@ function QuickAddBlock(props: QuickAddBlockProps) {
|
||||
>
|
||||
Delay
|
||||
</Button>
|
||||
{showBlocks && (
|
||||
{parentBlock === null && (
|
||||
<Button
|
||||
onClick={() => handleCreateEvent(SupportedEvent.Block)}
|
||||
onClick={addBlock}
|
||||
size='xs'
|
||||
variant='ontime-subtle-white'
|
||||
className={style.quickBtn}
|
||||
|
||||
@@ -29,7 +29,7 @@ export function makeRundownMetadata(selectedEventId: MaybeString) {
|
||||
isNext: false,
|
||||
isNextDay: false,
|
||||
totalGap: 0,
|
||||
isLinkedToLoaded: true,
|
||||
isLinkedToLoaded: false,
|
||||
isLoaded: false,
|
||||
};
|
||||
|
||||
@@ -56,6 +56,7 @@ function processEntry(
|
||||
processedData.isLoaded = false;
|
||||
processedData.previousEntryId = processedData.thisId;
|
||||
processedData.thisId = entry.id;
|
||||
processedData.previousEvent = processedData.latestEvent;
|
||||
|
||||
if (entry.id === selectedEventId) {
|
||||
processedData.isLoaded = true;
|
||||
@@ -65,19 +66,18 @@ function processEntry(
|
||||
if (isOntimeEvent(entry)) {
|
||||
// event indexes are 1 based in UI
|
||||
processedData.eventIndex += 1;
|
||||
processedData.previousEvent = processedData.latestEvent;
|
||||
|
||||
if (isPlayableEvent(entry)) {
|
||||
processedData.isNextDay = checkIsNextDay(entry, processedData.previousEvent);
|
||||
processedData.totalGap += entry.gap;
|
||||
|
||||
if (!processedData.isPast) {
|
||||
processedData.totalGap += entry.gap;
|
||||
if (!processedData.isPast && !processedData.isLoaded) {
|
||||
/**
|
||||
* isLinkToLoaded is a chain value that we maintain until we find an unlinked event
|
||||
* or we find a countToEnd event
|
||||
* isLinkToLoaded is a chain value that we maintain until we
|
||||
* a) find an unlinked event
|
||||
* b) find a countToEnd event
|
||||
*/
|
||||
processedData.isLinkedToLoaded =
|
||||
processedData.isLinkedToLoaded && entry.linkStart && !processedData.previousEvent?.countToEnd;
|
||||
processedData.isLinkedToLoaded = entry.linkStart && !processedData.previousEvent?.countToEnd;
|
||||
}
|
||||
|
||||
if (isNewLatest(entry, processedData.previousEvent)) {
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
import {
|
||||
CustomFields,
|
||||
LogOrigin,
|
||||
OntimeBlock,
|
||||
OntimeDelay,
|
||||
OntimeEvent,
|
||||
@@ -17,12 +16,12 @@ import { getCueCandidate } from 'ontime-utils';
|
||||
|
||||
import { block as blockDef, delay as delayDef } from '../../models/eventsDefinition.js';
|
||||
import { sendRefetch } from '../../adapters/websocketAux.js';
|
||||
import { logger } from '../../classes/Logger.js';
|
||||
import { createEvent } from '../../utils/parser.js';
|
||||
import { updateRundownData } from '../../stores/runtimeState.js';
|
||||
import { runtimeService } from '../runtime-service/RuntimeService.js';
|
||||
|
||||
import * as cache from './rundownCache.js';
|
||||
import { getInsertionPosition } from './rundownUtils.js';
|
||||
|
||||
type CompleteEntry<T> =
|
||||
T extends Partial<OntimeEvent>
|
||||
@@ -40,10 +39,6 @@ function generateEvent<T extends Partial<OntimeEvent> | Partial<OntimeDelay> | P
|
||||
eventData: T,
|
||||
afterId?: string,
|
||||
): CompleteEntry<T> {
|
||||
// TODO: could we keep the UI ID to avoid the flash on create?
|
||||
// we discard any UI provided IDs and add our own
|
||||
const id = cache.getUniqueId();
|
||||
|
||||
if (isOntimeEvent(eventData)) {
|
||||
const currentRundown = cache.getCurrentRundown();
|
||||
return createEvent(
|
||||
@@ -52,10 +47,13 @@ function generateEvent<T extends Partial<OntimeEvent> | Partial<OntimeDelay> | P
|
||||
) as CompleteEntry<T>;
|
||||
}
|
||||
|
||||
const id = eventData.id || cache.getUniqueId();
|
||||
|
||||
if (isOntimeDelay(eventData)) {
|
||||
return { ...delayDef, duration: eventData.duration ?? 0, id } as CompleteEntry<T>;
|
||||
}
|
||||
|
||||
// TODO(v4): allow user to provide a larger patch of the block entry
|
||||
if (isOntimeBlock(eventData)) {
|
||||
return { ...blockDef, title: eventData?.title ?? '', id } as CompleteEntry<T>;
|
||||
}
|
||||
@@ -67,41 +65,46 @@ function generateEvent<T extends Partial<OntimeEvent> | Partial<OntimeDelay> | P
|
||||
* creates a new event with given data
|
||||
*/
|
||||
export async function addEvent(eventData: EventPostPayload): Promise<OntimeEntry> {
|
||||
// if the user didnt provide an index, we add the event to start
|
||||
let atIndex = 0;
|
||||
let afterId: string | undefined = eventData?.after;
|
||||
// 1. we allow the user to provide an ID, but make sure it is unique
|
||||
if (eventData?.id && cache.hasId(eventData.id)) {
|
||||
throw new Error(`Event with ID ${eventData.id} already exists`);
|
||||
}
|
||||
|
||||
if (afterId) {
|
||||
const previousIndex = cache.getIndexOf(afterId);
|
||||
if (previousIndex < 0) {
|
||||
logger.warning(LogOrigin.Server, `Could not find event with id ${afterId}`);
|
||||
} else {
|
||||
atIndex = previousIndex + 1;
|
||||
// 2. if the user provides a parent (inside a group), we make sure it exists
|
||||
let parent: EntryId | undefined;
|
||||
if ('parent' in eventData && eventData.parent != null) {
|
||||
if (!cache.hasId(eventData.parent)) {
|
||||
throw new Error(`Parent event with ID ${eventData.parent} not found`);
|
||||
}
|
||||
} else if (eventData?.before !== undefined) {
|
||||
const previousIndex = cache.getIndexOf(eventData.before);
|
||||
if (previousIndex < 0) {
|
||||
logger.warning(LogOrigin.Server, `Could not find event with id ${eventData.before}`);
|
||||
} else {
|
||||
atIndex = previousIndex;
|
||||
if (previousIndex > 0) {
|
||||
afterId = cache.getIdOf(atIndex - 1);
|
||||
}
|
||||
parent = eventData.parent;
|
||||
}
|
||||
|
||||
// 3. if the user provides an after or before ID, we make sure it exists
|
||||
if (eventData?.after !== undefined) {
|
||||
if (!cache.hasId(eventData.after)) {
|
||||
throw new Error(`Event with ID ${eventData.after} not found`);
|
||||
}
|
||||
}
|
||||
if (eventData?.before !== undefined) {
|
||||
if (!cache.hasId(eventData.before)) {
|
||||
throw new Error(`Event with ID ${eventData.before} not found`);
|
||||
}
|
||||
}
|
||||
|
||||
// generate a fully formed event from the patch
|
||||
const eventToAdd = generateEvent(eventData, afterId);
|
||||
const { afterId, atIndex } = getInsertionPosition(parent, eventData?.after, eventData?.before);
|
||||
|
||||
// generate a fully formed entry from the patch
|
||||
const sanitisedEntry = generateEvent(eventData, afterId);
|
||||
|
||||
// modify rundown
|
||||
const scopedMutation = cache.mutateCache(cache.add);
|
||||
const { newEvent } = await scopedMutation({ atIndex, event: eventToAdd });
|
||||
const { newEvent } = await scopedMutation({ atIndex, parent, entry: sanitisedEntry });
|
||||
|
||||
// notify runtime that rundown has changed
|
||||
updateRuntimeOnChange();
|
||||
|
||||
// notify timer and external services of change
|
||||
notifyChanges({ timer: [eventToAdd.id], external: true });
|
||||
notifyChanges({ timer: [sanitisedEntry.id], external: true });
|
||||
|
||||
// we know this mutation returns an OntimeEntry
|
||||
return newEvent as OntimeEntry;
|
||||
|
||||
@@ -26,6 +26,7 @@ let currentRundown: Rundown = {
|
||||
id: '',
|
||||
title: '',
|
||||
order: [],
|
||||
flatOrder: [],
|
||||
entries: {},
|
||||
revision: 0,
|
||||
};
|
||||
@@ -101,6 +102,9 @@ export function generate(
|
||||
// we assign a reference to the current entry, this will be mutated in place
|
||||
const currentEntryId = initialRundown.order[i];
|
||||
const currentEntry = initialRundown.entries[currentEntryId];
|
||||
if (!currentEntry) {
|
||||
continue;
|
||||
}
|
||||
const { processedEntry } = process(currentEntry, null);
|
||||
|
||||
// if the event is a block, we process the nested entries
|
||||
@@ -115,6 +119,10 @@ export function generate(
|
||||
for (let i = 0; i < processedEntry.events.length; i++) {
|
||||
const nestedEntryId = processedEntry.events[i];
|
||||
const nestedEntry = initialRundown.entries[nestedEntryId];
|
||||
|
||||
if (!nestedEntry) {
|
||||
continue;
|
||||
}
|
||||
const { processedData: processedNestedData, processedEntry: processedNestedEntry } = process(
|
||||
nestedEntry,
|
||||
processedEntry.id,
|
||||
@@ -161,14 +169,22 @@ export function updateCache() {
|
||||
|
||||
// update the cache values
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-vars -- we are not interested in the iteration data
|
||||
const { entries, order, previousEvent, latestEvent, ...metadata } = processedData;
|
||||
currentRundown.entries = entries;
|
||||
currentRundown.order = order;
|
||||
const { previousEvent, latestEvent, ...metadata } = processedData;
|
||||
currentRundown.entries = metadata.entries;
|
||||
currentRundown.order = metadata.order;
|
||||
currentRundown.flatOrder = metadata.flatEventOrder;
|
||||
rundownMetadata = metadata;
|
||||
clearIsStale();
|
||||
customFieldChangelog = {};
|
||||
}
|
||||
|
||||
/**
|
||||
* Whether a given ID is exists in the current rundown
|
||||
*/
|
||||
export function hasId(id: EntryId): boolean {
|
||||
return Object.hasOwn(currentRundown.entries, id);
|
||||
}
|
||||
|
||||
/** Returns an ID guaranteed to be unique */
|
||||
export function getUniqueId(): string {
|
||||
if (isStale) {
|
||||
@@ -177,19 +193,19 @@ export function getUniqueId(): string {
|
||||
let id = '';
|
||||
do {
|
||||
id = generateId();
|
||||
} while (Object.hasOwn(currentRundown.entries, id));
|
||||
} while (hasId(id));
|
||||
return id;
|
||||
}
|
||||
|
||||
/** Returns index of an event with a given id */
|
||||
export function getIndexOf(eventId: EntryId) {
|
||||
/** Returns index of an entry with a given id */
|
||||
export function getIndexOf(entryId: EntryId) {
|
||||
if (isStale) {
|
||||
updateCache();
|
||||
}
|
||||
return currentRundown.order.indexOf(eventId);
|
||||
return currentRundown.order.indexOf(entryId);
|
||||
}
|
||||
|
||||
/** Returns id of an event at a given index */
|
||||
/** Returns id of an entry at a given index */
|
||||
export function getIdOf(index: number) {
|
||||
if (isStale) {
|
||||
updateCache();
|
||||
@@ -304,34 +320,60 @@ export function mutateCache<T extends object>(mutation: MutatingFn<T>) {
|
||||
return scopedMutation;
|
||||
}
|
||||
|
||||
type AddArgs = MutationParams<{ atIndex: number; event: OntimeEntry }>;
|
||||
type AddArgs = MutationParams<{ atIndex: number; parent?: EntryId; entry: OntimeEntry }>;
|
||||
/**
|
||||
* Add entry to rundown
|
||||
*/
|
||||
export function add({ rundown, atIndex, event }: AddArgs): Required<MutatingReturn> {
|
||||
const newEvent: OntimeEntry = { ...event };
|
||||
export function add({ rundown, atIndex, parent, entry }: AddArgs): Required<MutatingReturn> {
|
||||
const newEntry: OntimeEntry = { ...entry };
|
||||
|
||||
rundown.entries[newEntry.id] = newEntry;
|
||||
|
||||
if (parent) {
|
||||
const parentBlock = rundown.entries[parent] as OntimeBlock;
|
||||
parentBlock.events = insertAtIndex(atIndex, newEntry.id, parentBlock.events);
|
||||
} else {
|
||||
rundown.order = insertAtIndex(atIndex, newEntry.id, rundown.order);
|
||||
}
|
||||
|
||||
rundown.entries[newEvent.id] = newEvent;
|
||||
rundown.order = insertAtIndex(atIndex, newEvent.id, rundown.order);
|
||||
setIsStale();
|
||||
return { newRundown: rundown, newEvent, didMutate: true };
|
||||
return { newRundown: rundown, newEvent: newEntry, didMutate: true };
|
||||
}
|
||||
|
||||
type RemoveArgs = MutationParams<{ eventIds: EntryId[] }>;
|
||||
/**
|
||||
* Remove entry to rundown
|
||||
* Remove entries in a rundown
|
||||
*/
|
||||
export function remove({ rundown, eventIds }: RemoveArgs): MutatingReturn {
|
||||
const previousLength = rundown.order.length;
|
||||
rundown.order = rundown.order.filter((id) => !eventIds.includes(id));
|
||||
for (const id of eventIds) {
|
||||
delete rundown.entries[id];
|
||||
let didMutate = false;
|
||||
|
||||
for (let i = 0; i < eventIds.length; i++) {
|
||||
const entry = rundown.entries[eventIds[i]];
|
||||
if (isOntimeEvent(entry) && entry.parent) {
|
||||
const parentBlock = rundown.entries[entry.parent] as OntimeBlock;
|
||||
edit({
|
||||
rundown,
|
||||
eventId: entry.parent,
|
||||
patch: {
|
||||
events: parentBlock.events.filter((id) => id !== eventIds[i]),
|
||||
numEvents: parentBlock.events.length - 1,
|
||||
},
|
||||
});
|
||||
parentBlock.events = parentBlock.events.filter((id) => id !== entry.id);
|
||||
} else {
|
||||
rundown.order = rundown.order.filter((id) => id !== eventIds[i]);
|
||||
}
|
||||
didMutate = true;
|
||||
delete rundown.entries[eventIds[i]];
|
||||
}
|
||||
const didMutate = rundown.order.length !== previousLength;
|
||||
|
||||
if (didMutate) setIsStale();
|
||||
return { newRundown: rundown, didMutate };
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove all entries of a rundown
|
||||
*/
|
||||
export function removeAll(): MutatingReturn {
|
||||
setIsStale();
|
||||
return {
|
||||
@@ -339,6 +381,7 @@ export function removeAll(): MutatingReturn {
|
||||
id: '',
|
||||
title: '',
|
||||
order: [],
|
||||
flatOrder: [],
|
||||
entries: {},
|
||||
revision: 0,
|
||||
},
|
||||
@@ -441,6 +484,7 @@ export function reorder({ rundown, eventId, from, to }: ReorderArgs): Required<M
|
||||
type ApplyDelayArgs = MutationParams<{ delayId: EntryId }>;
|
||||
/**
|
||||
* Apply a delay
|
||||
* Mutates the given rundown
|
||||
*/
|
||||
export function applyDelay({ rundown, delayId }: ApplyDelayArgs): MutatingReturn {
|
||||
apply(delayId, rundown);
|
||||
|
||||
@@ -6,6 +6,7 @@ import {
|
||||
EntryId,
|
||||
RundownEntries,
|
||||
ProjectRundowns,
|
||||
OntimeBlock,
|
||||
} from 'ontime-types';
|
||||
|
||||
import * as cache from './rundownCache.js';
|
||||
@@ -173,3 +174,38 @@ export function getRundownOrThrow(rundowns: ProjectRundowns, rundownId: string):
|
||||
}
|
||||
return rundowns[rundownId];
|
||||
}
|
||||
|
||||
export function getInsertionPosition(
|
||||
parentId?: EntryId,
|
||||
afterId?: EntryId,
|
||||
beforeId?: EntryId,
|
||||
): { atIndex: number; afterId: EntryId | undefined } {
|
||||
if (afterId) {
|
||||
const order = selectOrderList(parentId);
|
||||
return {
|
||||
atIndex: order.findIndex((id) => id === afterId) + 1,
|
||||
afterId,
|
||||
};
|
||||
}
|
||||
|
||||
if (beforeId) {
|
||||
const order = selectOrderList(parentId);
|
||||
const atIndex = order.findIndex((id) => id === beforeId);
|
||||
return {
|
||||
atIndex,
|
||||
afterId: order[atIndex - 1] ?? null,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
atIndex: 0,
|
||||
afterId: undefined,
|
||||
};
|
||||
|
||||
function selectOrderList(parentId?: EntryId) {
|
||||
if (parentId) {
|
||||
return (getEntryWithId(parentId) as OntimeBlock).events;
|
||||
}
|
||||
return cache.getEventOrder().order;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -55,8 +55,8 @@ export type OntimeEvent = OntimeBaseEvent & {
|
||||
timeDanger: number;
|
||||
custom: EntryCustomFields;
|
||||
triggers?: Trigger[];
|
||||
// !==== RUNTIME METADATA ====! //
|
||||
parent: EntryId | null;
|
||||
// !==== RUNTIME METADATA ====! //
|
||||
revision: number;
|
||||
delay: number; // calculated at runtime
|
||||
dayOffset: number; // calculated at runtime
|
||||
|
||||
@@ -12,6 +12,7 @@ export type Rundown = {
|
||||
id: string;
|
||||
title: string;
|
||||
order: EntryId[];
|
||||
flatOrder: EntryId[];
|
||||
entries: RundownEntries;
|
||||
revision: number;
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user