wip: refactor

Author: Julusian

packages/job-worker/src/ingest/syncChangesToPartInstance.ts

@@ -94,6 +94,7 @@ export async function syncChangesToPartInstances(
 /**
  * Internal worker for syncing changes to PartInstances
  * Exposed for testing purposes
+ * Note: many methods are public so that they can be spied on in tests
  */
 export class SyncChangesToPartInstancesWorker {
 	readonly #context: JobContext
@@ -180,16 +181,16 @@ export class SyncChangesToPartInstancesWorker {
 	}
 
 	async syncChangesToPartInstance(instanceToSync: PartInstanceToSync): Promise<void> {
-		const { existingPartInstance, previousPartInstance, playStatus, newPart, piecesThatMayBeActive } =
-			instanceToSync
-		const pieceInstancesInPart = existingPartInstance.pieceInstances
+		const { existingPartInstance } = instanceToSync
 
 		const existingResultPartInstance: BlueprintSyncIngestPartInstance = {
 			partInstance: convertPartInstanceToBlueprints(existingPartInstance.partInstance),
-			pieceInstances: pieceInstancesInPart.map((p) => convertPieceInstanceToBlueprints(p.pieceInstance)),
+			pieceInstances: existingPartInstance.pieceInstances.map((p) =>
+				convertPieceInstanceToBlueprints(p.pieceInstance)
+			),
 		}
 
-		const part = newPart ?? existingPartInstance.partInstance.part
+		const part = instanceToSync.newPart ?? existingPartInstance.partInstance.part
 
 		let playoutRundownModelForPart: PlayoutRundownModel | undefined = this.#playoutRundownModel
 		// Handle a case where the part is in a different rundown than the playoutRundownModel:
@@ -205,10 +206,10 @@ export class SyncChangesToPartInstancesWorker {
 			proposedPieceInstances = getPieceInstancesForPart(
 				this.#context,
 				this.#playoutModel,
-				previousPartInstance,
+				instanceToSync.previousPartInstance,
 				playoutRundownModelForPart,
 				part,
-				await piecesThatMayBeActive,
+				await instanceToSync.piecesThatMayBeActive,
 				existingPartInstance.partInstance._id
 			)
 		} catch (e) {
@@ -223,14 +224,9 @@ export class SyncChangesToPartInstancesWorker {
 			throw e
 		}
 
-		logger.info(`Syncing ingest changes for part: ${part._id} (orphaned: ${!!newPart})`)
+		logger.info(`Syncing ingest changes for part: ${part._id} (orphaned: ${!!instanceToSync.newPart})`)
 
-		const newResultData = collectNewIngestDataToSync(
-			this.#ingestModel,
-			part._id,
-			instanceToSync,
-			proposedPieceInstances
-		)
+		const newResultData = this.collectNewIngestDataToSync(part._id, instanceToSync, proposedPieceInstances)
 		const partInstanceSnapshot = existingPartInstance.snapshotMakeCopy()
 
 		const syncContext = new SyncIngestUpdateToPartInstanceContext(
@@ -244,7 +240,7 @@ export class SyncChangesToPartInstancesWorker {
 			this.#playoutRundownModel.rundown,
 			existingPartInstance,
 			proposedPieceInstances,
-			playStatus
+			instanceToSync.playStatus
 		)
 		// TODO - how can we limit the frequency we run this? (ie, how do we know nothing affecting this has changed)
 		try {
@@ -256,7 +252,7 @@ export class SyncChangesToPartInstancesWorker {
 				syncContext,
 				existingResultPartInstance,
 				newResultData,
-				playStatus
+				instanceToSync.playStatus
 			)
 		} catch (err) {
 			logger.error(`Error in showStyleBlueprint.syncIngestUpdateToPartInstance: ${stringifyError(err)}`)
@@ -265,47 +261,20 @@ export class SyncChangesToPartInstancesWorker {
 			existingPartInstance.snapshotRestore(partInstanceSnapshot)
 		}
 
-		if (playStatus === 'next' && syncContext.hasRemovedPartInstance) {
+		if (instanceToSync.playStatus === 'next' && syncContext.hasRemovedPartInstance) {
 			// PartInstance was removed, so we need to remove it and re-select the next part
-
-			if (this.#playoutModel.playlist.nextPartInfo?.manuallySelected && newPart) {
-				await setNextPart(
-					this.#context,
-					this.#playoutModel,
-					{
-						part: newPart,
-						consumesQueuedSegmentId: this.#playoutModel.playlist.nextPartInfo.consumesQueuedSegmentId,
-					},
-					true,
-					this.#playoutModel.playlist.nextTimeOffset || 0
-				)
-			} else {
-				// Clear the next part
-				await setNextPart(this.#context, this.#playoutModel, null, false, 0)
-				await ensureNextPartIsValid(this.#context, this.#playoutModel)
-			}
+			await this.recreateNextPartInstance(instanceToSync.newPart)
 
 			// We don't need to continue syncing this partInstance, as it's been replaced
 			return
 		}
 
-		if (playStatus === 'next') {
+		if (instanceToSync.playStatus === 'next') {
 			existingPartInstance.recalculateExpectedDurationWithTransition()
 		}
 
 		// Save notes:
-		const notificationCategory = `syncIngestUpdateToPartInstance:${existingPartInstance.partInstance._id}`
-		this.#playoutModel.clearAllNotifications(notificationCategory)
-		for (const note of syncContext.notes) {
-			this.#playoutModel.setNotification(notificationCategory, {
-				...convertNoteToNotification(note, [this.#blueprint.blueprintId]),
-				relatedTo: {
-					type: 'partInstance',
-					rundownId: existingPartInstance.partInstance.part.rundownId,
-					partInstanceId: existingPartInstance.partInstance._id,
-				},
-			})
-		}
+		this.saveNotes(syncContext, existingPartInstance)
 
 		// Make sure an adlib-testing part is still labeled correctly. This could happen if the partInstance used any recently updated adlibs
 		validateAdlibTestingPartInstanceProperties(this.#context, this.#playoutModel, existingPartInstance)
@@ -321,33 +290,69 @@ export class SyncChangesToPartInstancesWorker {
 			)
 		}
 	}
-}
 
-function collectNewIngestDataToSync(
-	ingestModel: IngestModelReadonly,
-	partId: PartId,
-	instanceToSync: PartInstanceToSync,
-	proposedPieceInstances: PieceInstance[]
-): BlueprintSyncIngestNewData {
-	const ingestPart = ingestModel.findPart(partId)
-
-	const referencedAdlibs: IBlueprintAdLibPieceDB[] = []
-	for (const adLibPieceId of _.compact(
-		instanceToSync.existingPartInstance.pieceInstances.map((p) => p.pieceInstance.adLibSourceId)
-	)) {
-		const adLibPiece = ingestModel.findAdlibPiece(adLibPieceId)
-		if (adLibPiece) referencedAdlibs.push(convertAdLibPieceToBlueprints(adLibPiece))
+	collectNewIngestDataToSync(
+		partId: PartId,
+		instanceToSync: PartInstanceToSync,
+		proposedPieceInstances: PieceInstance[]
+	): BlueprintSyncIngestNewData {
+		const ingestPart = this.#ingestModel.findPart(partId)
+
+		const referencedAdlibs: IBlueprintAdLibPieceDB[] = []
+		for (const adLibPieceId of _.compact(
+			instanceToSync.existingPartInstance.pieceInstances.map((p) => p.pieceInstance.adLibSourceId)
+		)) {
+			const adLibPiece = this.#ingestModel.findAdlibPiece(adLibPieceId)
+			if (adLibPiece) referencedAdlibs.push(convertAdLibPieceToBlueprints(adLibPiece))
+		}
+
+		return {
+			part: instanceToSync.newPart ? convertPartToBlueprints(instanceToSync.newPart) : undefined,
+			pieceInstances: proposedPieceInstances.map(convertPieceInstanceToBlueprints),
+			adLibPieces:
+				instanceToSync.newPart && ingestPart ? ingestPart.adLibPieces.map(convertAdLibPieceToBlueprints) : [],
+			actions:
+				instanceToSync.newPart && ingestPart ? ingestPart.adLibActions.map(convertAdLibActionToBlueprints) : [],
+			referencedAdlibs: referencedAdlibs,
+			rundownPieces: this.#ingestModel.getGlobalPieces().map(convertRundownPieceToBlueprints),
+		}
 	}
 
-	return {
-		part: instanceToSync.newPart ? convertPartToBlueprints(instanceToSync.newPart) : undefined,
-		pieceInstances: proposedPieceInstances.map(convertPieceInstanceToBlueprints),
-		adLibPieces:
-			instanceToSync.newPart && ingestPart ? ingestPart.adLibPieces.map(convertAdLibPieceToBlueprints) : [],
-		actions:
-			instanceToSync.newPart && ingestPart ? ingestPart.adLibActions.map(convertAdLibActionToBlueprints) : [],
-		referencedAdlibs: referencedAdlibs,
-		rundownPieces: ingestModel.getGlobalPieces().map(convertRundownPieceToBlueprints),
+	async recreateNextPartInstance(newPart: ReadonlyDeep<DBPart> | undefined): Promise<void> {
+		if (this.#playoutModel.playlist.nextPartInfo?.manuallySelected && newPart) {
+			await setNextPart(
+				this.#context,
+				this.#playoutModel,
+				{
+					part: newPart,
+					consumesQueuedSegmentId: this.#playoutModel.playlist.nextPartInfo.consumesQueuedSegmentId,
+				},
+				true,
+				this.#playoutModel.playlist.nextTimeOffset || 0
+			)
+		} else {
+			// Clear the next part
+			await setNextPart(this.#context, this.#playoutModel, null, false, 0)
+			await ensureNextPartIsValid(this.#context, this.#playoutModel)
+		}
+	}
+
+	saveNotes(
+		syncContext: SyncIngestUpdateToPartInstanceContext,
+		existingPartInstance: PlayoutPartInstanceModel
+	): void {
+		const notificationCategory = `syncIngestUpdateToPartInstance:${existingPartInstance.partInstance._id}`
+		this.#playoutModel.clearAllNotifications(notificationCategory)
+		for (const note of syncContext.notes) {
+			this.#playoutModel.setNotification(notificationCategory, {
+				...convertNoteToNotification(note, [this.#blueprint.blueprintId]),
+				relatedTo: {
+					type: 'partInstance',
+					rundownId: existingPartInstance.partInstance.part.rundownId,
+					partInstanceId: existingPartInstance.partInstance._id,
+				},
+			})
+		}
 	}
 }