Merge pull request #1614 from tv2norge-collab/contribute/EAV-693

fix: converting pieces to infinites and modifying them

Author: ianshade

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

@@ -69,7 +69,7 @@ export interface IOnSetAsNextContext extends IShowStyleUserContext, IEventContex
 	 */
 	/** Insert a pieceInstance. Returns id of new PieceInstance. Any timelineObjects will have their ids changed, so are not safe to reference from another piece */
 	insertPiece(part: 'next', piece: IBlueprintPiece): Promise<IBlueprintPieceInstance>
-	/** Update a piecesInstance from the partInstance being set as Next */
+	/** Update a piecesInstance */
 	updatePieceInstance(pieceInstanceId: string, piece: Partial<IBlueprintPiece>): Promise<IBlueprintPieceInstance>
 
 	/** Update a partInstance */

packages/corelib/src/dataModel/PieceInstance.ts

@@ -61,6 +61,9 @@ export interface PieceInstance {
 	/** If this piece has been insterted during run of rundown (such as adLibs), then this is set to the timestamp it was inserted */
 	dynamicallyInserted?: Time
 
+	/** If this piece's lifespan has been changed to infinite during run of the rundown (adLib action, onTake, ...), then this is set to the timestamp it was changed */
+	dynamicallyConvertedToInfinite?: Time
+
 	/** This is set when the duration needs to be overriden from some user action */
 	userDuration?: {
 		/** The time relative to the part (milliseconds since start of part) */

packages/corelib/src/playout/__tests__/infinites.test.ts

@@ -177,6 +177,47 @@ describe('Infinites', () => {
 				},
 			])
 		})
+		test('piece dynamically converted to infinite should be continued', () => {
+			const playlistId = protectString('playlist0')
+			const rundownId = protectString('rundown0')
+			const segmentId = protectString('segment0')
+			const partId = protectString('part0')
+			const previousPartInstance = { rundownId, segmentId, partId }
+			const previousSegment = { _id: previousPartInstance.segmentId }
+			const previousPartPieces: PieceInstance[] = [
+				{
+					...createPieceInstanceAsInfinite(
+						'one',
+						rundownId,
+						partId,
+						{ start: 0 },
+						'one',
+						PieceLifespan.OutOnRundownEnd
+					),
+					dynamicallyConvertedToInfinite: Date.now(),
+				},
+			]
+			const segment = { _id: segmentId }
+			const part = { rundownId, segmentId }
+			const instanceId = protectString('newInstance0')
+			const rundown = createRundown(rundownId, playlistId, 'Test Rundown', 'rundown0')
+
+			const continuedInstances = runAndTidyResult(
+				previousPartInstance,
+				previousSegment,
+				previousPartPieces,
+				rundown,
+				segment,
+				part,
+				instanceId
+			)
+			expect(continuedInstances).toEqual([
+				{
+					_id: 'newInstance0_one_p_continue',
+					start: 0,
+				},
+			])
+		})
 		test('ignore pieces that have stopped', () => {
 			const playlistId = protectString('playlist0')
 			const rundownId = protectString('rundown0')

packages/corelib/src/playout/infinites.ts

@@ -181,7 +181,7 @@ export function getPlayheadTrackingInfinitesForPart(
 		// Check if we should persist any adlib onEnd infinites
 		if (canContinueAdlibOnEnds) {
 			const piecesByInfiniteMode = groupByToMapFunc(
-				pieceInstances.filter((p) => p.dynamicallyInserted),
+				pieceInstances.filter((p) => p.dynamicallyInserted || p.dynamicallyConvertedToInfinite),
 				(p) => p.piece.lifespan
 			)
 			for (const mode0 of [
@@ -194,7 +194,9 @@ export function getPlayheadTrackingInfinitesForPart(
 					| PieceLifespan.OutOnSegmentEnd
 					| PieceLifespan.OutOnShowStyleEnd
 				const pieces = (piecesByInfiniteMode.get(mode) || []).filter(
-					(p) => p.infinite && (p.infinite.fromPreviousPlayhead || p.dynamicallyInserted)
+					(p) =>
+						p.infinite &&
+						(p.infinite.fromPreviousPlayhead || p.dynamicallyInserted || p.dynamicallyConvertedToInfinite)
 				)
 				// This is the piece we may copy across
 				const candidatePiece =
@@ -277,6 +279,7 @@ export function getPlayheadTrackingInfinitesForPart(
 function markPieceInstanceAsContinuation(previousInstance: ReadonlyDeep<PieceInstance>, instance: PieceInstance) {
 	instance._id = protectString(`${instance._id}_continue`)
 	instance.dynamicallyInserted = previousInstance.dynamicallyInserted
+	instance.dynamicallyConvertedToInfinite = previousInstance.dynamicallyConvertedToInfinite
 	instance.adLibSourceId = previousInstance.adLibSourceId
 	instance.reportedStartedPlayback = previousInstance.reportedStartedPlayback
 	instance.plannedStartedPlayback = previousInstance.plannedStartedPlayback

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

@@ -22,7 +22,6 @@ import { WatchedPackagesHelper } from './watchedPackages.js'
 import { PlayoutModel } from '../../playout/model/PlayoutModel.js'
 import { ReadonlyDeep } from 'type-fest'
 import { getCurrentTime } from '../../lib/index.js'
-import { protectString } from '@sofie-automation/corelib/dist/protectedString'
 import { BlueprintQuickLookInfo } from '@sofie-automation/blueprints-integration/dist/context/quickLoopInfo'
 import { DBPart } from '@sofie-automation/corelib/dist/dataModel/Part'
 import { selectNewPartWithOffsets } from '../../playout/moveNextPart.js'
@@ -120,9 +119,6 @@ export class OnSetAsNextContext
 		pieceInstanceId: string,
 		piece: Partial<IBlueprintPiece<unknown>>
 	): Promise<IBlueprintPieceInstance<unknown>> {
-		if (protectString(pieceInstanceId) === this.playoutModel.playlist.currentPartInfo?.partInstanceId) {
-			throw new Error('Cannot update a Piece Instance from the current Part Instance')
-		}
 		return this.partAndPieceInstanceService.updatePieceInstance(pieceInstanceId, piece)
 	}
 

packages/job-worker/src/blueprints/context/services/PartAndPieceInstanceActionService.ts

@@ -318,7 +318,10 @@ export class PartAndPieceInstanceActionService {
 
 		const { pieceInstance } = foundPieceInstance
 
-		if (pieceInstance.pieceInstance.infinite?.fromPreviousPart) {
+		if (
+			pieceInstance.pieceInstance.infinite?.fromPreviousPart &&
+			pieceInstance.pieceInstance.partInstanceId === this._playoutModel.playlist.nextPartInfo?.partInstanceId
+		) {
 			throw new Error('Cannot update an infinite piece that is continued from a previous part')
 		}
 

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

@@ -1499,6 +1499,81 @@ describe('Test blueprint api context', () => {
 					expect(service.currentPartState).toEqual(ActionPartChange.SAFE_CHANGE)
 				})
 			})
+
+			test('can update infinite piece from previous part if in current part instance', async () => {
+				const { jobContext, playlistId, allPartInstances } = await setupMyDefaultRundown()
+
+				const currentPartInstance = allPartInstances[1]
+
+				// Create an infinite piece instance continued from previous part
+				const pieceInstance: PieceInstance = {
+					_id: protectString('piece_infinite'),
+					rundownId: currentPartInstance.partInstance.rundownId,
+					partInstanceId: currentPartInstance.partInstance._id,
+					playlistActivationId: currentPartInstance.partInstance.playlistActivationId,
+					piece: {
+						_id: protectString('piece_infinite_p'),
+						externalId: '-',
+						enable: { start: 0 },
+						name: 'infinite',
+						sourceLayerId: '',
+						outputLayerId: '',
+						startPartId: allPartInstances[0].partInstance.part._id,
+						content: {},
+						timelineObjectsString: EmptyPieceTimelineObjectsBlob,
+						lifespan: PieceLifespan.OutOnRundownEnd,
+						pieceType: IBlueprintPieceType.Normal,
+						invalid: false,
+					},
+					infinite: {
+						infiniteInstanceId: getRandomId(),
+						infiniteInstanceIndex: 1,
+						infinitePieceId: protectString('piece_infinite_p'),
+						fromPreviousPart: true,
+					},
+				}
+
+				await jobContext.mockCollections.PieceInstances.insertOne(pieceInstance)
+
+				await setPartInstances(jobContext, playlistId, currentPartInstance, undefined)
+
+				await wrapWithPlayoutModel(jobContext, playlistId, async (playoutModel) => {
+					const { service } = await getTestee(jobContext, playoutModel)
+
+					// Updating it in CURRENT part should succeed
+					await expect(
+						service.updatePieceInstance(unprotectString(pieceInstance._id), { name: 'updated' })
+					).resolves.toBeTruthy()
+				})
+			})
+
+			test('updating lifespan to infinite sets dynamicallyConvertedToInfinite', async () => {
+				const { jobContext, playlistId, allPartInstances } = await setupMyDefaultRundown()
+
+				const currentPartInstance = allPartInstances[0]
+				const pieceInstance = (await jobContext.mockCollections.PieceInstances.findOne({
+					partInstanceId: currentPartInstance.partInstance._id,
+				})) as PieceInstance
+				expect(pieceInstance).toBeTruthy()
+				expect(pieceInstance.piece.lifespan).toEqual(PieceLifespan.WithinPart)
+				expect(pieceInstance.infinite).toBeUndefined()
+
+				await setPartInstances(jobContext, playlistId, currentPartInstance, undefined)
+
+				await wrapWithPlayoutModel(jobContext, playlistId, async (playoutModel) => {
+					const { service } = await getTestee(jobContext, playoutModel)
+
+					await service.updatePieceInstance(unprotectString(pieceInstance._id), {
+						lifespan: PieceLifespan.OutOnRundownEnd,
+					})
+
+					const updatedPieceInstance = playoutModel.findPieceInstance(pieceInstance._id)?.pieceInstance
+					expect(updatedPieceInstance).toBeTruthy()
+					expect(updatedPieceInstance?.pieceInstance.piece.lifespan).toEqual(PieceLifespan.OutOnRundownEnd)
+					expect(updatedPieceInstance?.pieceInstance.infinite).toBeTruthy()
+					expect(updatedPieceInstance?.pieceInstance.dynamicallyConvertedToInfinite).toBeTruthy()
+				})
+			})
 		})
 
 		describe('stopPiecesOnLayers', () => {

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

@@ -2,10 +2,12 @@ import { ExpectedPackageId, PieceInstanceInfiniteId, RundownId } from '@sofie-au
 import { ReadonlyDeep } from 'type-fest'
 import { PieceInstance, PieceInstancePiece } from '@sofie-automation/corelib/dist/dataModel/PieceInstance'
 import { clone, getRandomId } from '@sofie-automation/corelib/dist/lib'
-import { ExpectedPackage, Time } from '@sofie-automation/blueprints-integration'
+import { ExpectedPackage, Time, PieceLifespan } from '@sofie-automation/blueprints-integration'
 import { PlayoutPieceInstanceModel } from '../PlayoutPieceInstanceModel.js'
 import _ from 'underscore'
 import { getExpectedPackageId } from '@sofie-automation/corelib/dist/dataModel/ExpectedPackages'
+import { setupPieceInstanceInfiniteProperties } from '../../pieces.js'
+import { getCurrentTime } from '../../../lib/time.js'
 
 export class PlayoutPieceInstanceModelImpl implements PlayoutPieceInstanceModel {
 	/**
@@ -158,6 +160,14 @@ export class PlayoutPieceInstanceModelImpl implements PlayoutPieceInstanceModel
 			},
 			true
 		)
+		if (
+			props.lifespan !== undefined &&
+			props.lifespan !== PieceLifespan.WithinPart &&
+			!this.PieceInstanceImpl.infinite
+		) {
+			setupPieceInstanceInfiniteProperties(this.PieceInstanceImpl)
+			this.PieceInstanceImpl.dynamicallyConvertedToInfinite = getCurrentTime()
+		}
 	}
 }