Moving 5-Years Of Files Into Year-Based Folders In Adobe ColdFusion 2021

<cfscript>

	cfsetting( requestTimeout = ( 60 * 10 ) );

	nextID = 0;

	// We're going to iterate over the blog entries, one by one, looking for content that
	// contains embedded upload paths. Then, we're going to move those files into year-
	// based buckets and update the entry content with the new path.
	do {

		entry = getNextEntry( nextID );

		// If there are no more entries, we're done - short-circuit the loop iteration,
		// which will then exit on account of the while-condition.
		if ( ! entry.recordCount ) {

			continue;

		}

		// It's possible that the upload path is part of either an IMG SRC attribute or
		// an ANCHOR HREF attribute. Extract the possible matches. I'm not sure if early
		// paths were fully-qualified, so we're making the domain optional.
		paths = entry.content_markdown
			.reMatch( "(src|href)=""(https?://www.bennadel.com)?/resources/uploads/[^""]+""" )
		;

		for ( path in paths ) {

			// Skip uploads that are already in a year-based folder.
			if ( path.reFind( "/resources/uploads/(20\d\d)/" ) ) {

				continue;

			}

			// Extract the path from the HTML attribute. Since our value is a quoted
			// attribute value, we can treat the pattern match like a quote-delimited
			// list.
			path = path.listGetAt( 2, """" );

			// Strip off any HTTP and domain prefix.
			localPath = path.reReplace( "^https?://[^/]+", "" );

			// Calculate the path that I would have used for the year-based bucketing of
			// the given file path.
			targetYear = entry.date_created.dateFormat( "yyyy" );
			targetPath = localPath.replace( "/uploads/", "/uploads/#targetYear#/" );

			// Get the fully-qualified server-paths for our files and directories.
			// --
			// NOTE: While Lucee CFML can use file-relative paths, Adobe ColdFusion has
			// to operate on fully-qualified paths (at least the last time I tested it).
			fullLocalPath = expandPath( "../.." & localPath );
			fullTargetPath = expandPath( "../.." & targetPath );
			fullTargetDirectory = getDirectoryFromPath( fullTargetPath );

			// After we copy the files to the new, bucketed location, we're going to MOVE
			// the original files to a temporary location for review (then delete them
			// manually because deleting is HELLA SCARY!!!).
			movedPath = localPath.replace( "/uploads/", "/uploads/__moved__/" );
			fullMovedPath = expandPath( "../.." & movedPath );
			fullMovedDirectory = getDirectoryFromPath( fullMovedPath );

			// Log the path on which we are operating.
			writeOutput(
				entry.id &
				" &rarr; " &
				targetYear &
				" &rarr; " &
				encodeForHtml( localPath ) &
				" &rarr; " &
				encodeForHtml( targetPath ) &
				"<br />"
			);

			// Since the blog entry content may be inaccurate, double-check that the file
			// actually exists. If not, warn and skip.
			if ( ! fileExists( fullLocalPath ) ) {

				writeOutput( "<strong>CAUTION:</strong> Doesn't exist <br />" );
				continue;

			}

			// Ensure the new target directory exists.
			// --
			// NOTE: ColdFusion 2021 will gracefully handle nested directories that don't
			// exist. As such, we don't have to worry about deep paths here.
			if ( ! directoryExists( fullTargetDirectory ) ) {

				directoryCreate( fullTargetDirectory );

			}

			// In case we run this script multiple times (or something may have been
			// buggy), only move the file if it doesn't exist in the target location.
			if ( ! fileExists( fullTargetPath ) ) {

				fileCopy( fullLocalPath, fullTargetPath );

			}

			// YOLO!! Commit the path changes to the database!
			updateEntry( entry.id, localPath, targetPath );

			// Now that we've updated our content, we can safely move the old files into
			// the temporary "__moved__" directory where I can review them before one
			// final delete!
			if ( ! directoryExists( fullMovedDirectory ) ) {

				directoryCreate( fullMovedDirectory );

			}

			if ( ! fileExists( fullMovedPath ) ) {

				fileMove( fullLocalPath, fullMovedPath );

			}

		}

		nextID = ( entry.id + 1 );

	} while ( entry.recordCount );

	// ------------------------------------------------------------------------------- //
	// ------------------------------------------------------------------------------- //

	/**
	* I look for the next blog entry that has "resource/uploads" path.
	*/
	public query function getNextEntry( required numeric minID ) {

		// NOTE: I'm using date-range because I know I started using folder-based
		// bucketing in 2011; so, any entry posted in 2012 or later should be OK.
		var results = queryExecute(
			"
				SELECT
					e.id,
					e.name,
					e.content_markdown,
					e.date_created
				FROM
					blog_entry e
				WHERE
					e.id >= :id
				AND
					e.date_created < '2012-01-01'
				AND
					e.content_markdown LIKE '%/resources/uploads/%'
				LIMIT
					1
			",
			{
				id: {
					value: minID,
					cfsqltype: "integer"
				}
			}
		);

		return( results );

	}


	/**
	* I update the content for the given entry, replacing root upload paths with the
	* given bucket-upload path.
	*/
	public void function updateEntry(
		required numeric id,
		required string localPath,
		required string targetPath
		) {

		var results = queryExecute(
			"
				UPDATE
					blog_entry
				SET
					content = REPLACE( content, :fromPath, :toPath ),
					content_markdown = REPLACE( content_markdown, :fromPath, :toPath ),
					formatted_content = REPLACE( formatted_content, :fromPath, :toPath )
				WHERE
					id = :id
				LIMIT
					1
			",
			{
				id: {
					value: id,
					cfsqltype: "cf_sql_integer"
				},
				fromPath: {
					value: localPath,
					cfsqltype: "cf_sql_varchar"
				},
				toPath: {
					value: targetPath,
					cfsqltype: "cf_sql_varchar"
				}
			}
		);

	}

</cfscript>