Handle drag and drop retime operations

Author: rjmunro

packages/blueprints/src/base/studio/userEditOperations/processIngestData.ts

@@ -106,11 +106,151 @@ async function applyUserOperation(
 		case DefaultUserOperationsTypes.UPDATE_PROPS:
 			processUpdateProps(context, mutableIngestRundown, changes.operationTarget, changes)
 			break
+		// Handle drag and drop retime operations:
+		case DefaultUserOperationsTypes.RETIME_PIECE:
+			processRetimePiece(context, mutableIngestRundown, changes.operationTarget, changes)
+			break
 		default:
 			context.logWarning(`Unknown operation: ${changes.operation.id}`)
 	}
 }
 
+/**
+ * Process piece retiming operations from the UI.
+ *
+ * This function handles drag-and-drop retime operations on pieces in the Sofie Rundown Editor.
+ * It modifies the underlying ingest data (objectTime and duration) for pieces within parts.
+ *
+ * Expected payload formats:
+ * - { newTime: number, newDuration?: number }
+ * - { deltaTime: number, deltaDuration?: number }
+ * - { startTime: number }
+ * - { timing: { start: number, duration?: number } }
+ *
+ * @param context - The ingest data processing context
+ * @param mutableIngestRundown - The mutable rundown being processed
+ * @param operationTarget - Target containing partExternalId and pieceExternalId
+ * @param changes - The user operation change containing timing information
+ */
+function processRetimePiece(
+	context: IProcessIngestDataContext,
+	mutableIngestRundown: BlueprintMutableIngestRundown,
+	operationTarget: UserOperationTarget,
+	changes: UserOperationChange<BlueprintsUserOperations | DefaultUserOperations>
+) {
+	// Extract piece timing information from the operation
+	const operation = changes.operation as any // DefaultUserOperationRetimePiece would be the proper type
+
+	context.logDebug('Processing piece retime operation: ' + JSON.stringify(changes, null, 2))
+
+	// Ensure we have the required identifiers
+	if (!operationTarget.partExternalId || !operationTarget.pieceExternalId) {
+		context.logError('Retime piece operation missing part or piece external ID')
+		return
+	}
+
+	// Find the part containing the piece
+	const part = mutableIngestRundown.findPart(operationTarget.partExternalId)
+	if (!part?.payload) {
+		context.logError(`Part not found for retime operation: ${operationTarget.partExternalId}`)
+		return
+	}
+
+	// Parse the part payload to access pieces
+	const partPayload: any = part.payload
+	if (!partPayload.pieces || !Array.isArray(partPayload.pieces)) {
+		context.logError(`Part has no pieces array: ${operationTarget.partExternalId}`)
+		return
+	}
+
+	context.logDebug('Original partPayload: ' + JSON.stringify(partPayload, null, 2))
+
+	// Find the specific piece to retime
+	const pieceIndex = partPayload.pieces.findIndex((piece: any) => piece.id === operationTarget.pieceExternalId)
+	if (pieceIndex === -1) {
+		context.logError(`Piece not found for retime: ${operationTarget.pieceExternalId}`)
+		return
+	}
+
+	const piece = partPayload.pieces[pieceIndex]
+	const originalTime = piece.objectTime || 0
+
+	// Extract new timing from operation payload
+	const payload = operation.payload || {}
+	const newTime = payload.inPoint / 1000 // Convert milliseconds to seconds for comparison
+
+	// Example payload structure for retime operations:
+	// 	"payload": {
+	//   "segmentExternalId": "d26d22e2-4f4e-4d31-a0ca-de6f37ff9b3f",
+	//   "partExternalId": "42077925-8d15-4a5d-abeb-a445ccee2984",
+	//   "inPoint": 1061.4136732329084
+	// }
+
+	// Handle different retime operation types
+	if (payload.inPoint === undefined) {
+		context.logError('Retime piece operation missing inPoint in payload')
+		return
+	}
+
+	// Check if there are any unknown values in the payload that need to be handled apart from inPoint, segmentExternalId, partExternalId
+	const knownKeys = ['inPoint', 'segmentExternalId', 'partExternalId']
+	const unknownKeys = Object.keys(payload).filter((key) => !knownKeys.includes(key))
+	if (unknownKeys.length > 0) {
+		context.logWarning(`Retime piece operation has unknown keys in payload: ${unknownKeys.join(', ')}`)
+	}
+
+	// Check if there are actually changes to apply (now comparing in the same units)
+	const timeDifference = Math.abs(newTime - originalTime)
+	if (timeDifference < 0.005) {
+		// Less than 5ms difference - consider it unchanged
+		context.logDebug(
+			`No significant timing changes needed for piece ${operationTarget.pieceExternalId} (${timeDifference}s difference)`
+		)
+		return
+	}
+
+	// Apply the retime changes to the ingest data structure
+	// Note: Ingest pieces use objectTime, not enable.start
+	const updatedPiece = {
+		...piece,
+		objectTime: newTime,
+	}
+
+	// Update the piece in the part payload
+	partPayload.pieces[pieceIndex] = updatedPiece
+
+	// Mark the part as modified using replacePayload
+	part.replacePayload(partPayload)
+
+	// Mark the segment/part as having been edited by the user
+	// This helps track that the content has been modified from the original ingest
+	const partAndSegment = mutableIngestRundown.findPartAndSegment(operationTarget.partExternalId)
+	if (partAndSegment?.segment && partAndSegment?.part) {
+		// Mark both segment and part as user-edited
+		partAndSegment.segment.setUserEditState(BlueprintUserOperationTypes.USER_EDITED, true)
+		partAndSegment.part.setUserEditState(BlueprintUserOperationTypes.USER_EDITED, true)
+
+		// Create a unique user edit state key for this piece retime operation
+		// This ensures each retime operation creates a new state change, triggering persistence
+		const pieceRetimeKey = `${operation.id}_${operationTarget.pieceExternalId}_${Date.now()}`
+
+		// Store the retime operation as a user edit state
+		// Each retime gets a unique key to ensure state changes trigger persistence
+		partAndSegment.segment.setUserEditState(pieceRetimeKey, true)
+		partAndSegment.part.setUserEditState(pieceRetimeKey, true)
+
+		// Also mark the specific operation that was performed
+		partAndSegment.segment.setUserEditState(operation.id, true)
+		partAndSegment.part.setUserEditState(operation.id, true)
+
+		// Lock both segment and part to prevent NRCS updates:
+		partAndSegment.segment.setUserEditState(BlueprintUserOperationTypes.LOCK_SEGMENT_NRCS_UPDATES, true)
+		partAndSegment.part.setUserEditState(BlueprintUserOperationTypes.LOCK_PART_NRCS_UPDATES, true)
+
+		context.logDebug(`Marked segment and part as user-edited and created unique retime state: ${pieceRetimeKey}`)
+	}
+}
+
 function processUpdateProps(
 	context: IProcessIngestDataContext,
 	mutableIngestRundown: BlueprintMutableIngestRundown,