Using IIS URL Rewriting And Application.cfc's OnMissingTemplate() Event Handler

# IIS Mod-Rewrite configuration file
# Turn on the rewrite rules for this access file. This will
# will handle all requests based off of this directory.

RewriteEngine On


# If the given file ends in .CFM or .CFC then just let the
# request carry on to the file system as it will be handled by
# the ColdFusion application framework (which is ultimately what
# we want it to be doing).
#
# NOTE: We don't care if the target CFM or CFC exists as this is
# going to be handled at the ColdFusion application framework
# level with the OnMissingTemplate() event handler.

RewriteRule \.c(fm|fc)$ - [NC,L]


# If the given file or directory exits, then don't do any
# redirects - simply pass the request on to the file system.

RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule .? - [L]


# If we have made it this far, then we know that the user
# requested a file or directory that didn't exist AND that file
# was not a ColdFusion file. As such, all we want to do is
# slap a .CFM file extension on this request so that it will
# end up triggering the ColdFusion application framework.
#
# NOTE: This will cause an internal redirect to a file ending
# in "-.cfm", which will be immediately passed through (to the
# ColdFusion application framework) by the first rule in this
# configuration file.

RewriteRule ^(.*)$ $1-.cfm [L]

RewriteRule \.c(fm|fc)$ - [NC,L]

RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule .? - [L]

RewriteRule ^(.*)$ $1-.cfm [L]

<cfcomponent
	output="false"
	hint="I define the application settings and event handlers.">

	<!--- Define the application. --->
	<cfset this.name = hash( getCurrentTemplatePath() ) />
	<cfset this.applicationTimeout = createTimeSpan( 0, 0, 5, 0 ) />

	<!--- Define page request settings. --->
	<cfsetting
		requesttimeout="10"
		showdebugoutput="false"
		/>


	<cffunction
		name="onApplicationStart"
		access="public"
		returntype="boolean"
		output="false"
		hint="I initialize the application.">

		<!--- Define the local scope. --->
		<cfset var local = {} />

		<!---
			As part of the application initialization, we
			want to figure out some constants surrounding our
			application location:

			RootDirectory
			The root directory of our application.

			RootScript
			The root script path of our application. This is in
			the case where our application lives below the web
			root of the server.

			RootUrl
			The root URL of our application.
		--->

		<!---
			Determining the root path is easy - we always know
			that it is this directory (the one containing the
			Application.cfc component).
		--->
		<cfset application.rootDirectory = getDirectoryFromPath(
			getCurrentTemplatePath()
			) />

		<!---
			To find the Root Script, we have to do a bit more
			calculation; we need to figure out the difference
			in the length between the root directory and
			requested directory and then subtract that depth
			from the requested script.
		--->

		<!---
			Start off with the current script directory as the
			root directory.
		--->
		<cfset application.rootScript = getDirectoryFromPath(
			cgi.script_name
			) />

		<!---
			Comparing the expanded root script to the root
			directory, we can now figure out how many directories
			below the application root we are.
		--->
		<cfset local.scriptDepth = (
			listLen( expandPath( application.rootScript ), "\/" ) -
			listLen( application.rootDirectory, "\/" )
			) />

		<!---
			Based on the script depth, we can now move up the path
			the corresponding number of steps.
		--->
		<cfset application.rootScript = reReplace(
			application.rootScript,
			"([^\\/]+[\\/]){#local.scriptDepth#}$",
			"",
			"one"
			) />

		<!---
			Now that we have our root script, we can easily find
			our root URL. The only special case we need to worry
			about is when the root script is "/". In that case,
			we are in the root of the web directory and don't need
			to append the script.
		--->
		<cfset application.rootUrl = (
			"http://" &
			cgi.server_name
			) />

		<!---
			Check to see if we have a script name worth appending
			to the URL.
		--->
		<cfif !reFind( "^[\\/]$", application.rootScript )>

			<!--- Append root script to URL. --->
			<cfset application.rootUrl &= application.rootScript />

		</cfif>

		<!--- Return true so the page request can process. --->
		<cfreturn true />
	</cffunction>


	<cffunction
		name="onRequestStart"
		access="public"
		returntype="boolean"
		output="false"
		hint="I intialize the page request.">

		<!--- Define arguments. --->
		<cfargument
			name="script"
			type="string"
			required="true"
			hint="I am the requested script name."
			/>

		<cfargument
			name="isSEO"
			type="boolean"
			required="false"
			default="false"
			hint="I flag whether or not the requested script was a SEO (search engine optimized) url. This will only be true if this event is being called by the OnMissingTemplate() event handler."
			/>

		<!--- Define the local scope. --->
		<cfset local = {} />

		<!---
			Combine the form and url scopes into a common request
			attributes collection so that we don't have to know
			what scope a variable came from.
		--->
		<cfset request.attributes = duplicate( url ) />
		<cfset structAppend( request.attributes, form ) />

		<!---
			Param the default action variable - this will be
			what the front-controller (and sub-controllers) use
			to figure out what scripts to execute.
		--->
		<cfparam
			name="request.attributes.do"
			type="string"
			default=""
			/>

		<!---
			Split the request variable into an array such that
			we can examine the parts of it in front-controller
			control flow. We are going to assume that the raw
			action variable is a dot-delimmited list of actions.
		--->
		<cfset request.do = listToArray(
			request.attributes.do,
			"."
			) />


		<!---
			Now that we have our action variable set up and based
			of the query string, let's check to see if the current
			page request is actually a URL Rewriting (an SEO url
			that was caught by the OnMissingTemplaet() event
			hanlder). If so, we might have to translate the URL
			into a new action AND a set of query string parameters.

			NOTE: Our IIS MOD-Rewrite interceptor rewrite rule
			will simply append "_.cfm" to any non-existing URL
			that doesn't already end in "cfm".
		--->
		<cfif arguments.isSEO>

			<!---
				Since the request script is based on the web root
				and NOT on our application root, let's remove
				anything above our application that will make our
				pattern matching more difficult. We can do this
				be substracting the root script from the user-
				requested script.

				This will leave us with application-relevant
				script values like:

				subdirectory/file.cfm

				Now, our patterns only have to worry about matching
				from the application-down, and not worry about the
				greater location of our application.
			--->
			<cfset local.script = replace(
				arguments.script,
				application.rootScript,
				"",
				"one"
				) />

			<!---
				Now that we have our script name calculated, let's
				use some regular expression pattern matching to
				see if we need to update our action varaible or
				any other URL variables.
			--->
			<cfif reFind( "^contact\b", local.script )>

				<!--- Routing to contact section. --->
				<cfset request.do = [ "contact" ] />

			<cfelseif reFind( "^about\b", local.script )>

				<!--- Routing to about section. --->
				<cfset request.do = [ "about" ] />

			<cfelseif reFind( "^blog/[\d+]", local.script )>

				<!--- Routing to blog section. --->
				<cfset request.do = [ "blog" ] />

				<!--- Get ID of blog post. --->
				<cfset request.attributes.id = listGetAt(
					local.script,
					2,
					"/"
					) />

			<cfelseif reFind( "^blog\b", local.script )>

				<!--- Routing to blog section. --->
				<cfset request.do = [ "blog" ] />

			<cfelse>

				<!---
					We could not match the requested URL against
					any of our SES patterns. As such, this is
					truly an invalid file request. As such, let's
					return a true 404 error.
				--->
				<cfheader
					statuscode="404"
					statustext="Page Not Found"
					/>

				<!---
					Return out with false so the request of the
					page will not get processed.
				--->
				<cfreturn false />

			</cfif>

		</cfif>


		<!---
			Get the relative web root path from our current page
			(this will allow our traversal path to always be
			relative, rather than a hard-coded root path, which
			is the lame).

			NOTE: Even if we end up including our front-controller,
			from the client (browser) perspective, the URL has not
			change. As such, our web root value must be calculated
			based on THAT url, not the template that we eventually
			end up executing.
		--->
		<cfset request.webRoot = repeatString(
			"../",
			(
				listLen( getDirectoryFromPath( expandPath( arguments.script ) ), "\\/" ) -
				listLen( application.rootDirectory, "\\/" )
			)) />


		<!--- Return true so that the page can be processed. --->
		<cfreturn true />
	</cffunction>


	<cffunction
		name="onRequest"
		access="public"
		returntype="void"
		output="true"
		hint="I execute the page request.">

		<!--- Define arguments. --->
		<cfargument
			name="script"
			type="string"
			required="true"
			hint="I am the requested script name."
			/>

		<!---
			Include the requested page. If the person requested
			a valid CFM page, then include it.

			NOTE: If this event is getting called from the
			OnMissingTempalte() event handler, then the script
			being passed in MAY NOT be the same script requested
			by the user.
		--->
		<cfinclude template="#arguments.script#" />

		<!--- Return out. --->
		<cfreturn />
	</cffunction>


	<cffunction
		name="onMissingTemplate"
		access="public"
		returntype="boolean"
		output="true"
		hint="I execute if the requested template does not exist.">

		<!--- Define arguments. --->
		<cfargument
			name="script"
			type="string"
			required="true"
			hint="I am the requested script name (but I do not exist on the physical file system)."
			/>

		<!---
			Since the OnMissingTemplate() event does not
			implicitly trigger the "request" events, we have to
			calls those explicitly. To stay in alignment with
			the intent of the OnRequestStart() event handler,
			let's call it as a part of a conditional.

			NOTE: The second argument, which is not normally
			supplied by the ColdFusion application framework, is
			a flag to the request method signaling that the
			requested script did NOT exist (such that any special
			processing can take place).
		--->
		<cfif this.onRequestStart( arguments.script, true )>

			<!---
				Explicitly execute the OnRequest() event handler.
				However, since we know that the requested script
				does NOT exist, we are going to override the
				requested script with the front-controller.
			--->
			<cfset this.onRequest( "index.cfm" ) />

			<!---
				Return true since the request executed
				successfully. This will prevent a 404 error from
				being thrown.
			--->
			<cfreturn true />

		<cfelse>

			<!---
				Since the onRequestStart() did not like the
				script name that was called, let's return false.
				This will trigger the actual "File Not Found"
				error at the ColdFusion level.
			--->
			<cfreturn false />

		</cfif>
	</cffunction>

</cfcomponent>

<cfoutput>

	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
	<html>
	<head>
		<title>IIS Mod-Rewrite ColdFusion Demo Application</title>
	</head>
	<body>

		<h1>
			IIS Mod-Rewrite ColdFusion Demo Application
		</h1>

		<h2>
			Test Links
		</h2>

		<p>
			<a href="#request.webRoot#contact/"
				>#request.webRoot#contact/</a><br />

			<a href="#request.webRoot#about/"
				>#request.webRoot#about/</a><br />

			<a href="#request.webRoot#blog/"
				>#request.webRoot#blog/</a><br />

			<a href="#request.webRoot#blog/1234/"
				>#request.webRoot#blog/1234/</a><br />
		</p>

		<h2>
			Relative Web Root
		</h2>

		<p>
			<cfif len( request.webRoot )>
				#request.webRoot#<br />
			<cfelse>
				[empty string]
			</cfif>
		</p>

		<h2>
			URL Scope
		</h2>

		<cfdump
			var="#url#"
			label="url"
			/>

		<h2>
			REQUEST Scope
		</h2>

		<cfdump
			var="#request#"
			label="request"
			/>

		<h2>
			APPLICATION Scope
		</h2>

		<cfdump
			var="#application#"
			label="application"
			/>

	</body>
	</html>

</cfoutput>