Merge branch 'feat/recue-next-part' into bbc-main-autonext

Author: PeterC89

packages/blueprints-integration/src/context/playoutActionContext.ts

@@ -11,6 +11,8 @@ export interface IPlayoutActionContext {
 	moveNextPart(partDelta: number, segmentDelta: number, ignoreQuickloop?: boolean): Promise<boolean>
 	/** Set flag to perform a take after the current handler completes. Returns state of the flag after each call. */
 	takeAfterExecuteAction(take: boolean): Promise<boolean>
+	/** Restore the next part instance to its original state, then reselect it so onSetAsNext runs again. */
+	recueNextPart(): Promise<void>
 	/** Insert a queued part to follow the current part */
 	queuePart(part: IBlueprintPart, pieces: IBlueprintPiece[]): Promise<IBlueprintPartInstance>
 	/** Insert a queued part to follow the taken part */

packages/job-worker/src/blueprints/__tests__/context-adlibActions.test.ts

@@ -1,5 +1,6 @@
 /* eslint-disable @typescript-eslint/unbound-method */
 import { IBlueprintMutatablePart, IBlueprintPart, IBlueprintPiece } from '@sofie-automation/blueprints-integration'
+import { ActionPartChange } from '../context/services/PartAndPieceInstanceActionService.js'
 import { ActionExecutionContext } from '../context/adlibActions.js'
 import { PlayoutModel } from '../../playout/model/PlayoutModel.js'
 import { WatchedPackagesHelper } from '../context/watchedPackages.js'
@@ -8,6 +9,7 @@ import { mock } from 'jest-mock-extended'
 import { PartAndPieceInstanceActionService } from '../context/services/PartAndPieceInstanceActionService.js'
 import { ProcessedShowStyleConfig } from '../config.js'
 import type { DBRundownPlaylist } from '@sofie-automation/corelib/dist/dataModel/RundownPlaylist/RundownPlaylist'
+import type { PlayoutPartInstanceModel } from '../../playout/model/PlayoutPartInstanceModel.js'
 
 describe('Test blueprint api context', () => {
 	async function getTestee(rehearsal?: boolean) {
@@ -44,6 +46,16 @@ describe('Test blueprint api context', () => {
 		}
 	}
 
+	function setupNextPartSnapshot(mockPlayoutModel: PlayoutModel) {
+		const mockNextPartInstance = mock<PlayoutPartInstanceModel>()
+		mockNextPartInstance.recueNextPart.mockImplementation(() => undefined)
+		Object.defineProperty(mockPlayoutModel, 'nextPartInstance', {
+			get: () => mockNextPartInstance,
+		})
+
+		return { mockNextPartInstance }
+	}
+
 	describe('ActionExecutionContext', () => {
 		test('getPartInstance', async () => {
 			const { context, mockActionService } = await getTestee()
@@ -131,6 +143,20 @@ describe('Test blueprint api context', () => {
 			expect(mockActionService.updatePieceInstance).toHaveBeenCalledWith('pieceId', { name: 'My Piece' })
 		})
 
+		test('recueNextPart restores the next part snapshot and clears next state', async () => {
+			const { context, mockActionService, mockPlayoutModel } = await getTestee()
+			const { mockNextPartInstance } = setupNextPartSnapshot(mockPlayoutModel)
+
+			mockActionService.nextPartState = ActionPartChange.SAFE_CHANGE
+
+			await context.recueNextPart()
+
+			expect(mockNextPartInstance.recueNextPart).toHaveBeenCalledTimes(1)
+			expect(mockActionService.nextPartState).toBe(ActionPartChange.NONE)
+			expect(context.forceRegenerateTimeline).toBe(true)
+			expect(context.recueAfterExecute).toBe(true)
+		})
+
 		test('queuePart', async () => {
 			const { context, mockActionService } = await getTestee()
 

packages/job-worker/src/blueprints/context/adlibActions.ts

@@ -75,6 +75,7 @@ export class DatastoreActionExecutionContext
 /** Actions */
 export class ActionExecutionContext extends ShowStyleUserContext implements IActionExecutionContext, IEventContext {
 	readonly #tTimersService: TTimersService
+	public recueAfterExecute = false
 
 	/**
 	 * Whether the blueprints requested a take to be performed at the end of this action
@@ -239,6 +240,18 @@ export class ActionExecutionContext extends ShowStyleUserContext implements IAct
 		return this.takeAfterExecute
 	}
 
+	async recueNextPart(): Promise<void> {
+		const nextPartInstance = this._playoutModel.nextPartInstance
+		if (!nextPartInstance) {
+			throw new Error('Cannot recue next part when no next part instance is set')
+		}
+
+		nextPartInstance.recueNextPart()
+		this.partAndPieceInstanceService.nextPartState = ActionPartChange.NONE
+		this.forceRegenerateTimeline = true
+		this.recueAfterExecute = true
+	}
+
 	async blockTakeUntil(time: Time | null): Promise<void> {
 		if (time !== null && (time < getCurrentTime() || typeof time !== 'number'))
 			throw new Error('Cannot block taking out of the current part, to a time in the past')

packages/job-worker/src/playout/__tests__/playout-executeAction.test.ts

@@ -10,9 +10,11 @@ import { ActionExecutionContext } from '../../blueprints/context/adlibActions.js
 import { ActionPartChange } from '../../blueprints/context/services/PartAndPieceInstanceActionService.js'
 import * as Infinites from '../../playout/infinites.js'
 import * as TakeApi from '../../playout/take.js'
+import * as SetNextApi from '../setNext.js'
 
 const syncPlayheadInfinitesForNextPartInstanceMock = jest.spyOn(Infinites, 'syncPlayheadInfinitesForNextPartInstance')
 const takeNextPartMock = jest.spyOn(TakeApi, 'performTakeToNextedPart')
+const setNextPartMock = jest.spyOn(SetNextApi, 'setNextPart')
 
 jest.mock('../timeline/generate')
 import { updateTimeline } from '../timeline/generate.js'
@@ -44,6 +46,7 @@ describe('Playout API', () => {
 			syncPlayheadInfinitesForNextPartInstanceMock.mockClear()
 			updateTimelineMock.mockClear()
 			takeNextPartMock.mockClear()
+			setNextPartMock.mockClear()
 		})
 
 		test('throws errors', async () => {
@@ -200,5 +203,27 @@ describe('Playout API', () => {
 
 			expect(takeNextPartMock).toHaveBeenCalledTimes(0)
 		})
+
+		test('recue next part reruns setNext', async () => {
+			setNextPartMock.mockImplementationOnce(async () => Promise.resolve())
+
+			context.updateShowStyleBlueprint({
+				executeAction: async (context) => {
+					await context.recueNextPart()
+				},
+			})
+
+			const actionDocId: AdLibActionId = protectString('action-id')
+			const actionId = 'some-action'
+			const userData = { blobby: true }
+			await handleExecuteAdlibAction(context, {
+				playlistId,
+				actionDocId,
+				actionId,
+				userData,
+			})
+
+			expect(setNextPartMock).toHaveBeenCalledTimes(1)
+		})
 	})
 })

packages/job-worker/src/playout/adlibAction.ts

@@ -33,6 +33,7 @@ import {
 	PartAndPieceInstanceActionService,
 	applyActionSideEffects,
 } from '../blueprints/context/services/PartAndPieceInstanceActionService.js'
+import { setNextPart } from './setNext.js'
 import { convertNoteToNotification } from '../notifications/util.js'
 import type { INoteBase } from '@sofie-automation/corelib/dist/dataModel/Notes'
 import { NotificationsModelHelper } from '../notifications/NotificationsModelHelper.js'
@@ -317,6 +318,16 @@ export async function applyAnyExecutionSideEffects(
 ): Promise<void> {
 	await applyActionSideEffects(context, playoutModel, actionContext)
 
+	if (actionContext.recueAfterExecute) {
+		actionContext.recueAfterExecute = false
+		const nextPartInstance = playoutModel.nextPartInstance
+		if (!nextPartInstance) {
+			throw new Error('Cannot recue next part when no next part instance is set')
+		}
+
+		await setNextPart(context, playoutModel, nextPartInstance, true)
+	}
+
 	if (actionContext.takeAfterExecute) {
 		await performTakeToNextedPart(context, playoutModel, now, actionContext.partToQueueAfterTake)
 	} else if (

packages/job-worker/src/playout/model/PlayoutPartInstanceModel.ts

@@ -42,6 +42,12 @@ export interface PlayoutPartInstanceModel {
 	 */
 	snapshotMakeCopy(): PlayoutPartInstanceModelSnapshot
 
+	/** Snapshot captured when this part was set as next, used to restore the original nexted state. */
+	recueNextPartSnapshot?: PlayoutPartInstanceModelSnapshot
+
+	/** Restore the previously stored rescue snapshot, if any, and refresh it for future rescues. */
+	recueNextPart(): void
+
 	/**
 	 * Restore a snapshot of this PlayoutPartInstanceModel, to rollback to a previous state
 	 * Note: It is only possible to restore each snapshot once.

packages/job-worker/src/playout/model/implementation/PlayoutModelImpl.ts

@@ -380,6 +380,8 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 	}
 
 	clearSelectedPartInstances(): void {
+		const nextPartInstance = this.nextPartInstance
+		if (nextPartInstance) nextPartInstance.recueNextPartSnapshot = undefined
 		this.playlistImpl.currentPartInfo = null
 		this.playlistImpl.nextPartInfo = null
 		this.playlistImpl.previousPartInfo = null
@@ -552,6 +554,9 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 	}
 
 	cycleSelectedPartInstances(): void {
+		const nextPartInstance = this.nextPartInstance
+		if (nextPartInstance) nextPartInstance.recueNextPartSnapshot = undefined
+
 		this.playlistImpl.previousPartInfo = this.playlistImpl.currentPartInfo
 		this.playlistImpl.currentPartInfo = this.playlistImpl.nextPartInfo
 		this.playlistImpl.nextPartInfo = null
@@ -663,6 +668,8 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 	 * Reset the playlist for playout
 	 */
 	resetPlaylist(regenerateActivationId: boolean): void {
+		const nextPartInstance = this.nextPartInstance
+		if (nextPartInstance) nextPartInstance.recueNextPartSnapshot = undefined
 		this.playlistImpl.previousPartInfo = null
 		this.playlistImpl.currentPartInfo = null
 		this.playlistImpl.nextPartInfo = null
@@ -803,6 +810,7 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 		consumesQueuedSegmentId: boolean,
 		nextTimeOffset?: number
 	): void {
+		const previousNextPartInstance = this.nextPartInstance
 		if (partInstance) {
 			const storedPartInstance = this.allPartInstances.get(partInstance.partInstance._id)
 			if (!storedPartInstance) throw new Error(`PartInstance being set as next was not constructed correctly`)
@@ -811,6 +819,10 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 				throw new Error(`PartInstance being set as next is not current`)
 		}
 
+		if (previousNextPartInstance && previousNextPartInstance.partInstance._id !== partInstance?.partInstance._id) {
+			previousNextPartInstance.recueNextPartSnapshot = undefined
+		}
+
 		if (partInstance) {
 			this.playlistImpl.nextPartInfo = literal<SelectedPartInstance>({
 				partInstanceId: partInstance.partInstance._id,

packages/job-worker/src/playout/model/implementation/PlayoutPartInstanceModelImpl.ts

@@ -1,4 +1,9 @@
-import { PieceId, PieceInstanceId, RundownPlaylistActivationId } from '@sofie-automation/corelib/dist/dataModel/Ids'
+import {
+	PartInstanceId,
+	PieceId,
+	PieceInstanceId,
+	RundownPlaylistActivationId,
+} from '@sofie-automation/corelib/dist/dataModel/Ids'
 import { ReadonlyDeep } from 'type-fest'
 import { DBPartInstance } from '@sofie-automation/corelib/dist/dataModel/PartInstance'
 import {
@@ -39,9 +44,11 @@ interface PlayoutPieceInstanceModelSnapshotImpl {
 	PieceInstance: PieceInstance
 	HasChanges: boolean
 }
+
+const recueNextPartSnapshots = new Map<PartInstanceId, PlayoutPartInstanceModelSnapshot>()
+
 class PlayoutPartInstanceModelSnapshotImpl implements PlayoutPartInstanceModelSnapshot {
 	readonly __isPlayoutPartInstanceModelBackup = true
-
 	isRestored = false
 
 	readonly partInstance: DBPartInstance
@@ -70,6 +77,21 @@ export class PlayoutPartInstanceModelImpl implements PlayoutPartInstanceModel {
 	partInstanceImpl: DBPartInstance
 	pieceInstancesImpl: Map<PieceInstanceId, PlayoutPieceInstanceModelImpl | null>
 	quickLoopService: QuickLoopService
+	#recueNextPartSnapshot: PlayoutPartInstanceModelSnapshot | undefined
+
+	get recueNextPartSnapshot(): PlayoutPartInstanceModelSnapshot | undefined {
+		return this.#recueNextPartSnapshot
+	}
+
+	set recueNextPartSnapshot(snapshot: PlayoutPartInstanceModelSnapshot | undefined) {
+		this.#recueNextPartSnapshot = snapshot
+		const partInstanceId = this.partInstanceImpl?._id
+		if (partInstanceId) {
+			if (snapshot) recueNextPartSnapshots.set(partInstanceId, snapshot)
+			else recueNextPartSnapshots.delete(partInstanceId)
+		}
+		this.#partInstanceHasChanges = true
+	}
 
 	#setPartInstanceValue<T extends keyof DBPartInstance>(key: T, newValue: DBPartInstance[T]): void {
 		if (newValue === undefined) {
@@ -169,6 +191,8 @@ export class PlayoutPartInstanceModelImpl implements PlayoutPartInstanceModel {
 		this.partInstanceImpl = partInstance
 		this.#partInstanceHasChanges = hasChanges
 		this.quickLoopService = quickLoopService
+		const partInstanceId = partInstance?._id
+		this.#recueNextPartSnapshot = partInstanceId ? recueNextPartSnapshots.get(partInstanceId) : undefined
 
 		this.pieceInstancesImpl = new Map()
 		for (const pieceInstance of pieceInstances) {
@@ -188,29 +212,54 @@ export class PlayoutPartInstanceModelImpl implements PlayoutPartInstanceModel {
 		return new PlayoutPartInstanceModelSnapshotImpl(this)
 	}
 
+	recueNextPart(): void {
+		if (!this.recueNextPartSnapshot) {
+			throw new Error('Cannot recue next part when no snapshot is available')
+		}
+
+		this.snapshotRestore(this.recueNextPartSnapshot)
+		this.recueNextPartSnapshot = this.snapshotMakeCopy()
+	}
+
 	snapshotRestore(snapshot: PlayoutPartInstanceModelSnapshot): void {
-		if (!(snapshot instanceof PlayoutPartInstanceModelSnapshotImpl))
+		if (!snapshot.__isPlayoutPartInstanceModelBackup)
 			throw new Error(`Cannot restore a Snapshot from an different Model`)
 
-		if (snapshot.partInstance._id !== this.partInstance._id)
+		const snapshotImpl = snapshot as PlayoutPartInstanceModelSnapshotImpl & {
+			pieceInstances:
+				| ReadonlyMap<PieceInstanceId, PlayoutPieceInstanceModelSnapshotImpl | null>
+				| Record<string, PlayoutPieceInstanceModelSnapshotImpl | null>
+		}
+
+		if (snapshotImpl.partInstance._id !== this.partInstance._id)
 			throw new Error(`Cannot restore a Snapshot from an different PartInstance`)
 
-		if (snapshot.isRestored) throw new Error(`Cannot restore a Snapshot which has already been restored`)
-		snapshot.isRestored = true
+		if (snapshotImpl.isRestored) throw new Error(`Cannot restore a Snapshot which has already been restored`)
+		snapshotImpl.isRestored = true
 
-		this.partInstanceImpl = snapshot.partInstance
-		this.#partInstanceHasChanges = snapshot.partInstanceHasChanges
-		this.pieceInstancesImpl.clear()
-		for (const [pieceInstanceId, pieceInstance] of snapshot.pieceInstances) {
+		this.partInstanceImpl = snapshotImpl.partInstance
+		for (const pieceInstanceId of this.pieceInstancesImpl.keys()) {
+			this.pieceInstancesImpl.set(pieceInstanceId, null)
+		}
+		const pieceInstancesEntries =
+			snapshotImpl.pieceInstances instanceof Map
+				? snapshotImpl.pieceInstances.entries()
+				: Object.entries<PlayoutPieceInstanceModelSnapshotImpl | null>(
+						snapshotImpl.pieceInstances as Record<string, PlayoutPieceInstanceModelSnapshotImpl | null>
+					)
+
+		for (const [pieceInstanceId, pieceInstance] of pieceInstancesEntries) {
 			if (pieceInstance) {
 				this.pieceInstancesImpl.set(
-					pieceInstanceId,
+					pieceInstanceId as PieceInstanceId,
 					new PlayoutPieceInstanceModelImpl(pieceInstance.PieceInstance, pieceInstance.HasChanges)
 				)
 			} else {
-				this.pieceInstancesImpl.set(pieceInstanceId, null)
+				this.pieceInstancesImpl.set(pieceInstanceId as PieceInstanceId, null)
 			}
 		}
+
+		this.#partInstanceHasChanges = true
 	}
 
 	blockTakeUntil(timestamp: Time | null): void {